diff --git a/annotations/com/intellij/psi/annotations.xml b/annotations/com/intellij/psi/annotations.xml index 5b4da145766..53593e6d34f 100644 --- a/annotations/com/intellij/psi/annotations.xml +++ b/annotations/com/intellij/psi/annotations.xml @@ -304,6 +304,9 @@ + + + diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 972fdba4f07..be168b2783c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -76,6 +76,7 @@ import java.util.*; import static org.jetbrains.jet.codegen.AsmUtil.*; import static org.jetbrains.jet.codegen.JvmCodegenUtil.*; import static org.jetbrains.jet.codegen.binding.CodegenBinding.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.resolve.BindingContextUtils.getNotNull; import static org.jetbrains.jet.lang.resolve.BindingContextUtils.isVarCapturedInClosure; @@ -2561,7 +2562,7 @@ public class ExpressionCodegen extends JetVisitor implem } } fakeFunctionCall.append(")"); - return (JetCallExpression) JetPsiFactory.createExpression(state.getProject(), fakeFunctionCall.toString()); + return (JetCallExpression) JetPsiFactory(state.getProject()).createExpression(fakeFunctionCall.toString()); } private void computeAndSaveArguments(@NotNull List fakeArguments, @NotNull ExpressionCodegen codegen) { @@ -2581,7 +2582,7 @@ public class ExpressionCodegen extends JetVisitor implem ) { if (receiver == null) return NO_RECEIVER; - JetExpression receiverExpression = JetPsiFactory.createExpression(state.getProject(), "callableReferenceFakeReceiver"); + JetExpression receiverExpression = JetPsiFactory(state.getProject()).createExpression("callableReferenceFakeReceiver"); codegen.tempVariables.put(receiverExpression, receiverParameterStackValue(signature)); return new ExpressionReceiver(receiverExpression, receiver.getType()); } @@ -3938,7 +3939,7 @@ The "returned" value of try expression with no finally is either the last expres } private Call makeFakeCall(ReceiverValue initializerAsReceiver) { - JetSimpleNameExpression fake = JetPsiFactory.createSimpleName(state.getProject(), "fake"); + JetSimpleNameExpression fake = JetPsiFactory(state.getProject()).createSimpleName("fake"); return CallMaker.makeCall(fake, initializerAsReceiver); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java index 47bdd20fdc3..c7721091b44 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeFieldSignatureData.java @@ -22,13 +22,14 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.JetProperty; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.java.resolver.ExternalAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaField; import org.jetbrains.jet.lang.types.JetType; import java.util.HashMap; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class AlternativeFieldSignatureData extends ElementAlternativeSignatureData { private JetType altReturnType; @@ -47,7 +48,7 @@ public class AlternativeFieldSignatureData extends ElementAlternativeSignatureDa } setAnnotated(true); - JetProperty altPropertyDeclaration = JetPsiFactory.createProperty(project, signature); + JetProperty altPropertyDeclaration = JetPsiFactory(project).createProperty(signature); try { checkForSyntaxErrors(altPropertyDeclaration); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java index bc49b2b6526..2c518f4d5b8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java @@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT; import static org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage.UPPER_BOUND; @@ -76,7 +77,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD } setAnnotated(true); - altFunDeclaration = JetPsiFactory.createFunction(project, signature); + altFunDeclaration = JetPsiFactory(project).createFunction(signature); originalToAltTypeParameters = DescriptorResolverUtils.recreateTypeParametersAndReturnMapping(methodTypeParameters, null); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java index 6b3b989448f..e9005b35684 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java @@ -22,6 +22,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiModifiableCodeBlock; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.ReadOnly; import org.jetbrains.jet.lexer.JetTokens; import java.util.Arrays; @@ -42,6 +43,7 @@ public class JetBlockExpression extends JetExpressionImpl implements JetStatemen return visitor.visitBlockExpression(this, data); } + @ReadOnly @NotNull public List getStatements() { return Arrays.asList(findChildrenByClass(JetElement.class)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt index 9b8816147be..520cf6bc687 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt @@ -100,7 +100,7 @@ public abstract class JetCodeFragment( } fun importsAsImportList(): JetImportList? { - return JetPsiFactory.createFile(_project, _myImports.makeString("\n")).getImportList() + return JetPsiFactory(_project).createFile(_myImports.makeString("\n")).getImportList() } override fun setVisibilityChecker(checker: JavaCodeFragment.VisibilityChecker?) { } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImpl.java index f1f1a1cbed1..e665eae3c56 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImpl.java +++ b/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(JetPsiFactory.createExpression(getProject(), "(" + newElement.getText() + ")")); + return super.replace(PsiPackage.JetPsiFactory(getProject()).createExpression("(" + newElement.getText() + ")")); } return super.replace(newElement); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImplStub.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImplStub.java index 20fa3e487da..20cb6872019 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImplStub.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImplStub.java @@ -44,7 +44,7 @@ public abstract class JetExpressionImplStub extends JetEl PsiElement parent = getParent(); if (parent instanceof JetExpression && newElement instanceof JetExpression && JetPsiUtil.areParenthesesNecessary((JetExpression) newElement, this, (JetExpression) parent)) { - return super.replace(JetPsiFactory.createExpression(getProject(), "(" + newElement.getText() + ")")); + return super.replace(PsiPackage.JetPsiFactory(getProject()).createExpression("(" + newElement.getText() + ")")); } return super.replace(newElement); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java index 8db2349e1c0..801d95196fe 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java @@ -28,6 +28,8 @@ import javax.inject.Inject; import java.util.Collection; import java.util.Map; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetImportsFactory { @NotNull private Project project; @@ -47,7 +49,7 @@ public class JetImportsFactory { return directive; } - JetImportDirective createdDirective = JetPsiFactory.createImportDirective(project, importPath); + JetImportDirective createdDirective = JetPsiFactory(project).createImportDirective(importPath); importsCache.put(importPath, createdDirective); return createdDirective; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationNotStubbed.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationNotStubbed.java index a1da56e04cc..81073e024de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationNotStubbed.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationNotStubbed.java @@ -21,10 +21,11 @@ import com.intellij.psi.PsiElement; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lexer.JetTokens; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + // TODO: Remove when all named declarations get stubs @Deprecated abstract class JetNamedDeclarationNotStubbed extends JetDeclarationImpl implements JetNamedDeclaration { @@ -63,7 +64,7 @@ abstract class JetNamedDeclarationNotStubbed extends JetDeclarationImpl implemen @Override public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException { - return getNameIdentifier().replace(JetPsiFactory.createNameIdentifier(getProject(), name)); + return getNameIdentifier().replace(JetPsiFactory(getProject()).createNameIdentifier(name)); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java index 32b239b9bf2..d9cb3ac26f2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java @@ -30,6 +30,8 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lexer.JetTokens; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + abstract class JetNamedDeclarationStub extends JetDeclarationStub implements JetNamedDeclaration { public JetNamedDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) { super(stub, nodeType); @@ -75,7 +77,7 @@ abstract class JetNamedDeclarationStub extends J @Override public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException { - return getNameIdentifier().replace(JetPsiFactory.createNameIdentifier(getProject(), name)); + return getNameIdentifier().replace(JetPsiFactory(getProject()).createNameIdentifier(name)); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java index 0c708fbef1b..7d372f1dc07 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java +++ b/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(JetPsiFactory.createNameIdentifier(getProject(), name)); + return getNameIdentifier().replace(PsiPackage.JetPsiFactory(getProject()).createNameIdentifier(name)); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.kt b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.kt index 928a3ce4e45..3e7457e2170 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,713 +14,569 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.psi; +package org.jetbrains.jet.lang.psi -import com.intellij.lang.ASTNode; -import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFileFactory; -import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.util.LocalTimeCounter; -import kotlin.KotlinPackage; -import kotlin.Pair; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.ImportPath; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lexer.JetKeywordToken; -import org.jetbrains.jet.plugin.JetFileType; +import com.intellij.lang.ASTNode +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiFileFactory +import com.intellij.psi.util.PsiTreeUtil +import com.intellij.util.LocalTimeCounter +import org.jetbrains.jet.lang.resolve.ImportPath +import org.jetbrains.jet.lexer.JetKeywordToken +import org.jetbrains.jet.plugin.JetFileType -import java.util.Collection; -import java.util.Collections; -import java.util.List; +public fun JetPsiFactory(project: Project?): JetPsiFactory = JetPsiFactory(project!!) -public class JetPsiFactory { +public class JetPsiFactory(private val project: Project) { - @NotNull - public static ASTNode createValNode(Project project) { - JetProperty property = createProperty(project, "val x = 1"); - return property.getValOrVarNode(); + public fun createValNode(): ASTNode { + val property = createProperty("val x = 1") + return property.getValOrVarNode() } - @NotNull - public static ASTNode createVarNode(Project project) { - JetProperty property = createProperty(project, "var x = 1"); - return property.getValOrVarNode(); + public fun createVarNode(): ASTNode { + val property = createProperty("var x = 1") + return property.getValOrVarNode() } - @NotNull - public static ASTNode createValOrVarNode(Project project, String text) { - return createParameterList(project, "(" + text + " int x)").getParameters().get(0).getValOrVarNode(); + public fun createValOrVarNode(text: String): ASTNode { + return createParameterList("($text int x)").getParameters().first().getValOrVarNode()!! } - @NotNull - public static JetExpression createExpression(Project project, String text) { - JetProperty property = createProperty(project, "val x = " + text); - return property.getInitializer(); + public fun createExpression(text: String): JetExpression { + return createProperty("val x = $text").getInitializer()!! } - @NotNull - public static JetValueArgumentList createCallArguments(Project project, String text) { - JetProperty property = createProperty(project, "val x = foo" + text); - JetExpression initializer = property.getInitializer(); - JetCallExpression callExpression = (JetCallExpression) initializer; - return callExpression.getValueArgumentList(); + public fun createCallArguments(text: String): JetValueArgumentList { + val property = createProperty("val x = foo $text") + return (property.getInitializer() as JetCallExpression).getValueArgumentList()!! } - @NotNull - public static JetTypeArgumentList createTypeArguments(Project project, String text) { - JetProperty property = createProperty(project, "val x = foo" + text + "()"); - JetExpression initializer = property.getInitializer(); - JetCallExpression callExpression = (JetCallExpression) initializer; - return callExpression.getTypeArgumentList(); + public fun createTypeArguments(text: String): JetTypeArgumentList { + val property = createProperty("val x = foo$text()") + return (property.getInitializer() as JetCallExpression).getTypeArgumentList()!! } - @NotNull - public static JetTypeReference createType(Project project, String type) { - JetProperty property = createProperty(project, "val x : " + type); - return property.getTypeRef(); + public fun createType(`type`: String): JetTypeReference { + return createProperty("val x : $`type`").getTypeRef()!! } - @NotNull - public static PsiElement createStar(Project project) { - PsiElement star = createType(project, "List<*>").findElementAt(5); - assert star != null; - return star; + public fun createStar(): PsiElement { + return createType("List<*>").findElementAt(5)!! } - @NotNull - public static PsiElement createComma(Project project) { - PsiElement comma = createType(project, "T").findElementAt(3); - assert comma != null; - return comma; + public fun createComma(): PsiElement { + return createType("T").findElementAt(3)!! } - @NotNull - public static PsiElement createColon(Project project) { - JetProperty property = createProperty(project, "val x: Int"); - PsiElement colon = property.findElementAt(5); - assert colon != null; - return colon; + public fun createColon(): PsiElement { + return createProperty("val x: Int").findElementAt(5)!! } - @NotNull - public static PsiElement createEQ(Project project) { - PsiElement eq = createFunction(project, "fun foo() = foo").getEqualsToken(); - assert eq != null; - return eq; + public fun createEQ(): PsiElement { + return createFunction("fun foo() = foo").getEqualsToken()!! } - @NotNull - public static PsiElement createSemicolon(Project project) { - JetProperty property = createProperty(project, "val x: Int;"); - PsiElement semicolon = property.findElementAt(10); - assert semicolon != null; - return semicolon; + public fun createSemicolon(): PsiElement { + return createProperty("val x: Int;").findElementAt(10)!! } //the pair contains the first and the last elements of a range - @NotNull - public static Pair createWhitespaceAndArrow(Project project) { - JetFunctionType functionType = (JetFunctionType) createType(project, "() -> Int").getTypeElement(); - assert functionType != null; - return new Pair(functionType.findElementAt(2), functionType.findElementAt(3)); + public fun createWhitespaceAndArrow(): Pair { + val functionType = createType("() -> Int").getTypeElement() as JetFunctionType + return Pair(functionType.findElementAt(2)!!, functionType.findElementAt(3)!!) } - @NotNull - public static PsiElement createWhiteSpace(Project project) { - return createWhiteSpace(project, " "); + public fun createWhiteSpace(): PsiElement { + return createWhiteSpace(" ") } - @NotNull - public static PsiElement createWhiteSpace(Project project, String text) { - JetProperty property = createProperty(project, "val" + text + "x"); - return property.findElementAt(3); + public fun createWhiteSpace(text: String): PsiElement { + return createProperty("val${text}x").findElementAt(3)!! } - @NotNull - public static PsiElement createNewLine(Project project) { - return createWhiteSpace(project, "\n"); + public fun createNewLine(): PsiElement { + return createWhiteSpace("\n") } - @NotNull - public static JetClass createClass(@NotNull Project project, @NotNull String text) { - return createDeclaration(project, text, JetClass.class); + public fun createClass(text: String): JetClass { + return createDeclaration(text) } - @NotNull - public static JetFile createFile(@NotNull Project project, @NotNull String text) { - return createFile(project, "dummy.kt", text); + public fun createFile(text: String): JetFile { + return createFile("dummy.kt", text) } - @NotNull - public static JetFile createFile(@NotNull Project project, @NotNull String fileName, @NotNull String text) { - return (JetFile) PsiFileFactory.getInstance(project).createFileFromText(fileName, JetFileType.INSTANCE, text, - LocalTimeCounter.currentTime(), false); + public fun createFile(fileName: String, text: String): JetFile { + return PsiFileFactory.getInstance(project).createFileFromText(fileName, JetFileType.INSTANCE, text, LocalTimeCounter.currentTime(), false) as JetFile } - @NotNull - public static JetFile createPhysicalFile(@NotNull Project project, @NotNull String fileName, @NotNull String text) { - return (JetFile) PsiFileFactory.getInstance(project).createFileFromText(fileName, JetFileType.INSTANCE, text, - LocalTimeCounter.currentTime(), true); + public fun createPhysicalFile(fileName: String, text: String): JetFile { + return PsiFileFactory.getInstance(project).createFileFromText(fileName, JetFileType.INSTANCE, text, LocalTimeCounter.currentTime(), true) as JetFile } - @NotNull - public static JetProperty createProperty(Project project, String name, String type, boolean isVar, @Nullable String initializer) { - String text = (isVar ? "var " : "val ") + name + (type != null ? ":" + type : "") + (initializer == null ? "" : " = " + initializer); - return createProperty(project, text); + public fun createProperty(name: String, `type`: String?, isVar: Boolean, initializer: String?): JetProperty { + val text = (if (isVar) "var " else "val ") + name + (if (`type` != null) ":" + `type` else "") + (if (initializer == null) "" else " = " + initializer) + return createProperty(text) } - @NotNull - public static JetProperty createProperty(Project project, String name, String type, boolean isVar) { - return createProperty(project, name, type, isVar, null); + public fun createProperty(name: String, `type`: String?, isVar: Boolean): JetProperty { + return createProperty(name, `type`, isVar, null) } - @NotNull - public static JetProperty createProperty(Project project, String text) { - return createDeclaration(project, text, JetProperty.class); + public fun createProperty(text: String): JetProperty { + return createDeclaration(text) } - @NotNull - public static T createDeclaration(Project project, String text, Class clazz) { - JetFile file = createFile(project, text); - List dcls = file.getDeclarations(); - assert dcls.size() == 1 : dcls.size() + " declarations in " + text; - @SuppressWarnings("unchecked") - T result = (T) dcls.get(0); - return result; + public fun createDeclaration(text: String): T { + val file = createFile(text) + val dcls = file.getDeclarations() + assert(dcls.size() == 1) { "${dcls.size()} declarations in $text" } + [suppress("UNCHECKED_CAST")] + val result = dcls.first() as T + return result } - @NotNull - public static PsiElement createNameIdentifier(Project project, String name) { - return createProperty(project, name, null, false).getNameIdentifier(); + public fun createNameIdentifier(name: String): PsiElement { + return createProperty(name, null, false).getNameIdentifier()!! } - @NotNull - public static JetSimpleNameExpression createSimpleName(Project project, String name) { - return (JetSimpleNameExpression) createProperty(project, name, null, false, name).getInitializer(); + public fun createSimpleName(name: String): JetSimpleNameExpression { + return createProperty(name, null, false, name).getInitializer() as JetSimpleNameExpression } - @NotNull - public static PsiElement createIdentifier(Project project, String name) { - return createSimpleName(project, name).getIdentifier(); + public fun createIdentifier(name: String): PsiElement { + return createSimpleName(name).getIdentifier()!! } - @NotNull - public static JetNamedFunction createFunction(Project project, String funDecl) { - return createDeclaration(project, funDecl, JetNamedFunction.class); + public fun createFunction(funDecl: String): JetNamedFunction { + return createDeclaration(funDecl) } - @NotNull - public static JetModifierList createModifierList(Project project, JetKeywordToken modifier) { - return createModifierList(project, modifier.getValue()); + public fun createModifierList(modifier: JetKeywordToken): JetModifierList { + return createModifierList(modifier.getValue()) } - @NotNull - public static JetModifierList createModifierList(Project project, String text) { - JetProperty property = createProperty(project, text + " val x"); - return property.getModifierList(); + public fun createModifierList(text: String): JetModifierList { + return createProperty(text + " val x").getModifierList()!! } - @NotNull - public static JetAnnotation createAnnotation(Project project, String text) { - JetProperty property = createProperty(project, text + " val x"); - JetModifierList modifierList = property.getModifierList(); - assert modifierList != null; - return modifierList.getAnnotations().get(0); + public fun createAnnotation(text: String): JetAnnotation { + val modifierList = createProperty(text + " val x").getModifierList() + return modifierList!!.getAnnotations().first() } - @NotNull - public static JetModifierList createConstructorModifierList(Project project, JetKeywordToken modifier) { - JetClass aClass = createClass(project, "class C " + modifier.getValue() + " (){}"); - return aClass.getPrimaryConstructorModifierList(); + public fun createConstructorModifierList(modifier: JetKeywordToken): JetModifierList { + val aClass = createClass("class C ${modifier.getValue()} (){}") + return aClass.getPrimaryConstructorModifierList()!! } - @NotNull - public static JetExpression createEmptyBody(Project project) { - JetNamedFunction function = createFunction(project, "fun foo() {}"); - return function.getBodyExpression(); + public fun createEmptyBody(): JetExpression { + return createFunction("fun foo() {}").getBodyExpression()!! } - @NotNull - public static JetClassBody createEmptyClassBody(Project project) { - JetClass aClass = createClass(project, "class A(){}"); - return aClass.getBody(); + public fun createEmptyClassBody(): JetClassBody { + return createClass("class A(){}").getBody()!! } - @NotNull - public static JetParameter createParameter(Project project, String name, String type) { - JetNamedFunction function = createFunction(project, "fun foo(" + name + " : " + type + ") {}"); - return function.getValueParameters().get(0); + public fun createParameter(name: String, `type`: String): JetParameter { + val function = createFunction("fun foo(" + name + " : " + `type` + ") {}") + return function.getValueParameters().first() } - @NotNull - public static JetParameterList createParameterList(Project project, String text) { - JetNamedFunction function = createFunction(project, "fun foo" + text + "{}"); - return function.getValueParameterList(); + public fun createParameterList(text: String): JetParameterList { + return createFunction("fun foo$text{}").getValueParameterList()!! } - @NotNull - public static JetWhenEntry createWhenEntry(@NotNull Project project, @NotNull String entryText) { - JetNamedFunction function = createFunction(project, "fun foo() { when(12) { " + entryText + " } }"); - JetWhenEntry whenEntry = PsiTreeUtil.findChildOfType(function, JetWhenEntry.class); + public fun createWhenEntry(entryText: String): JetWhenEntry { + val function = createFunction("fun foo() { when(12) { $entryText } }") + val whenEntry = PsiTreeUtil.findChildOfType(function, javaClass()) - assert whenEntry != null : "Couldn't generate when entry"; - assert entryText.equals(whenEntry.getText()) : "Generate when entry text differs from the given text"; + assert(whenEntry != null, "Couldn't generate when entry") + assert(entryText == whenEntry!!.getText(), "Generate when entry text differs from the given text") - return whenEntry; + return whenEntry } - @NotNull - public static JetStringTemplateEntryWithExpression createBlockStringTemplateEntry(@NotNull Project project, @NotNull JetExpression expression) { - JetStringTemplateExpression stringTemplateExpression = (JetStringTemplateExpression) createExpression(project, - "\"${" + expression.getText() + "}\""); - return (JetStringTemplateEntryWithExpression) stringTemplateExpression.getEntries()[0]; + public fun createBlockStringTemplateEntry(expression: JetExpression): JetStringTemplateEntryWithExpression { + val stringTemplateExpression = createExpression("\"\${${expression.getText()}}\"") as JetStringTemplateExpression + return stringTemplateExpression.getEntries().first() as JetStringTemplateEntryWithExpression } - @NotNull - public static JetImportDirective createImportDirective(Project project, @NotNull String path) { - return createImportDirective(project, new ImportPath(path)); + public fun createImportDirective(path: String): JetImportDirective { + return createImportDirective(ImportPath(path)) } - @NotNull - public static JetImportDirective createImportDirective(Project project, @NotNull ImportPath importPath) { + public fun createImportDirective(importPath: ImportPath): JetImportDirective { if (importPath.fqnPart().isRoot()) { - throw new IllegalArgumentException("import path must not be empty"); + throw IllegalArgumentException("import path must not be empty") } - StringBuilder importDirectiveBuilder = new StringBuilder("import "); - importDirectiveBuilder.append(importPath.getPathStr()); + val importDirectiveBuilder = StringBuilder("import ") + importDirectiveBuilder.append(importPath.getPathStr()) - Name alias = importPath.getAlias(); + val alias = importPath.getAlias() if (alias != null) { - importDirectiveBuilder.append(" as ").append(alias.asString()); + importDirectiveBuilder.append(" as ").append(alias.asString()) } - JetFile file = createFile(project, importDirectiveBuilder.toString()); - return file.getImportDirectives().iterator().next(); + val file = createFile(importDirectiveBuilder.toString()) + return file.getImportDirectives().first() } - @NotNull - public static JetImportList createImportDirectiveWithImportList(Project project, @NotNull ImportPath importPath) { - JetImportDirective importDirective = createImportDirective(project, importPath); - return (JetImportList) importDirective.getParent(); + public fun createImportDirectiveWithImportList(importPath: ImportPath): JetImportList { + val importDirective = createImportDirective(importPath) + return importDirective.getParent() as JetImportList } - @NotNull - public static PsiElement createPrimaryConstructor(Project project) { - JetClass aClass = createClass(project, "class A()"); - return aClass.findElementAt(7).getParent(); + public fun createPrimaryConstructor(): PsiElement { + return createClass("class A()").findElementAt(7)!!.getParent()!! } - @NotNull - public static JetSimpleNameExpression createClassLabel(Project project, @NotNull String labelName) { - JetThisExpression expression = (JetThisExpression) createExpression(project, "this@" + labelName); - return expression.getTargetLabel(); + public fun createClassLabel(labelName: String): JetSimpleNameExpression { + return (createExpression("this@$labelName") as JetThisExpression).getTargetLabel()!! } - @NotNull - public static JetExpression createFieldIdentifier(Project project, @NotNull String fieldName) { - return createExpression(project, "$" + fieldName); + public fun createFieldIdentifier(fieldName: String): JetExpression { + return createExpression("$$fieldName") } - @NotNull - public static JetBinaryExpression createBinaryExpression(Project project, @NotNull String lhs, @NotNull String op, @NotNull String rhs) { - return (JetBinaryExpression) createExpression(project, lhs + " " + op + " " + rhs); + public fun createBinaryExpression(lhs: String, op: String, rhs: String): JetBinaryExpression { + return createExpression("$lhs $op $rhs") as JetBinaryExpression } - @NotNull - public static JetBinaryExpression createBinaryExpression(Project project, @Nullable JetExpression lhs, @NotNull String op, @Nullable JetExpression rhs) { - return createBinaryExpression(project, JetPsiUtil.getText(lhs), op, JetPsiUtil.getText(rhs)); + public fun createBinaryExpression(lhs: JetExpression?, op: String, rhs: JetExpression?): JetBinaryExpression { + return createBinaryExpression(JetPsiUtil.getText(lhs), op, JetPsiUtil.getText(rhs)) } - @NotNull - public static JetTypeCodeFragment createTypeCodeFragment(Project project, String text, PsiElement context) { - return new JetTypeCodeFragment(project, "fragment.kt", text, context); + public fun createTypeCodeFragment(text: String, context: PsiElement?): JetTypeCodeFragment { + return JetTypeCodeFragment(project, "fragment.kt", text, context) } - @NotNull - public static JetExpressionCodeFragment createExpressionCodeFragment(Project project, String text, PsiElement context) { - return new JetExpressionCodeFragment(project, "fragment.kt", text, context); + public fun createExpressionCodeFragment(text: String, context: PsiElement?): JetExpressionCodeFragment { + return JetExpressionCodeFragment(project, "fragment.kt", text, context) } - @NotNull - public static JetBlockCodeFragment createBlockCodeFragment(Project project, String text, PsiElement context) { - return new JetBlockCodeFragment(project, "fragment.kt", text, context); + public fun createBlockCodeFragment(text: String, context: PsiElement?): JetBlockCodeFragment { + return JetBlockCodeFragment(project, "fragment.kt", text, context) } - @NotNull - public static JetReturnExpression createReturn(Project project, @NotNull String text) { - return (JetReturnExpression) createExpression(project, "return " + text); + public fun createReturn(text: String): JetReturnExpression { + return createExpression("return $text") as JetReturnExpression } - @NotNull - public static JetReturnExpression createReturn(Project project, @Nullable JetExpression expression) { - return createReturn(project, JetPsiUtil.getText(expression)); + public fun createReturn(expression: JetExpression?): JetReturnExpression { + return createReturn(JetPsiUtil.getText(expression)) } - @NotNull - public static JetIfExpression createIf(Project project, - @Nullable JetExpression condition, @Nullable JetExpression thenExpr, @Nullable JetExpression elseExpr) { - return (JetIfExpression) createExpression(project, JetPsiUnparsingUtils.toIf(condition, thenExpr, elseExpr)); + public fun createIf(condition: JetExpression?, thenExpr: JetExpression?, elseExpr: JetExpression?): JetIfExpression { + return createExpression(JetPsiUnparsingUtils.toIf(condition, thenExpr, elseExpr)) as JetIfExpression } - @NotNull - public static JetValueArgument createArgumentWithName( - @NotNull Project project, - @NotNull String name, - @NotNull JetExpression argumentExpression - ) { - return createCallArguments(project, "(" + name + " = " + argumentExpression.getText() + ")").getArguments().get(0); + public fun createArgumentWithName(name: String, argumentExpression: JetExpression): JetValueArgument { + return createCallArguments("(" + name + " = " + argumentExpression.getText() + ")").getArguments().first() } - public static class IfChainBuilder { - private final StringBuilder sb = new StringBuilder(); - private boolean first = true; - private boolean frozen = false; + public inner class IfChainBuilder() { + private val sb = StringBuilder() + private var first = true + private var frozen = false - public IfChainBuilder() { - } - - @NotNull - public IfChainBuilder ifBranch(@NotNull String conditionText, @NotNull String expressionText) { + public fun ifBranch(conditionText: String, expressionText: String): IfChainBuilder { if (first) { - first = false; - } else { - sb.append("else "); + first = false + } + else { + sb.append("else ") } - sb.append("if (").append(conditionText).append(") ").append(expressionText).append("\n"); - return this; + sb.append("if (").append(conditionText).append(") ").append(expressionText).append("\n") + return this } - @NotNull - public IfChainBuilder ifBranch(@NotNull JetExpression condition, @NotNull JetExpression expression) { - return ifBranch(condition.getText(), expression.getText()); + public fun ifBranch(condition: JetExpression, expression: JetExpression): IfChainBuilder { + return ifBranch(condition.getText()!!, expression.getText()!!) } - @NotNull - public IfChainBuilder elseBranch(@NotNull String expressionText) { - sb.append("else ").append(expressionText); - return this; + public fun elseBranch(expressionText: String): IfChainBuilder { + sb.append("else ").append(expressionText) + return this } - @NotNull - public IfChainBuilder elseBranch(@Nullable JetExpression expression) { - return elseBranch(JetPsiUtil.getText(expression)); + public fun elseBranch(expression: JetExpression?): IfChainBuilder { + return elseBranch(JetPsiUtil.getText(expression)) } - @NotNull - public JetIfExpression toExpression(Project project) { + public fun toExpression(): JetIfExpression { if (!frozen) { - frozen = true; + frozen = true } - return (JetIfExpression) createExpression(project, sb.toString()); + return createExpression(sb.toString()) as JetIfExpression } } - public static class WhenBuilder { - private final StringBuilder sb = new StringBuilder("when "); - private boolean frozen = false; - private boolean inCondition = false; + public inner class WhenBuilder(subjectText: String?) { + private val sb = StringBuilder("when ") + private var frozen = false + private var inCondition = false - public WhenBuilder() { - this((String)null); - } - - public WhenBuilder(@Nullable String subjectText) { - if (subjectText != null) { - sb.append("(").append(subjectText).append(") "); - } - sb.append("{\n"); - } - - public WhenBuilder(@Nullable JetExpression subject) { - this(subject != null ? subject.getText() : null); - } - - @NotNull - public WhenBuilder condition(@NotNull String text) { - assert !frozen; + public fun condition(text: String): WhenBuilder { + assert(!frozen) if (!inCondition) { - inCondition = true; - } else { - sb.append(", "); + inCondition = true } - sb.append(text); + else { + sb.append(", ") + } + sb.append(text) - return this; + return this } - @NotNull - public WhenBuilder condition(@Nullable JetExpression expression) { - return condition(JetPsiUtil.getText(expression)); + public fun condition(expression: JetExpression?): WhenBuilder { + return condition(JetPsiUtil.getText(expression)) } - @NotNull - public WhenBuilder pattern(@NotNull String typeReferenceText, boolean negated) { - return condition((negated ? "!is" : "is") + " " + typeReferenceText); + public fun pattern(typeReferenceText: String, negated: Boolean): WhenBuilder { + return condition((if (negated) "!is" else "is") + " " + typeReferenceText) } - @NotNull - public WhenBuilder pattern(@Nullable JetTypeReference typeReference, boolean negated) { - return pattern(JetPsiUtil.getText(typeReference), negated); + public fun pattern(typeReference: JetTypeReference?, negated: Boolean): WhenBuilder { + return pattern(JetPsiUtil.getText(typeReference), negated) } - @NotNull - public WhenBuilder range(@NotNull String argumentText, boolean negated) { - return condition((negated ? "!in" : "in") + " " + argumentText); + public fun range(argumentText: String, negated: Boolean): WhenBuilder { + return condition((if (negated) "!in" else "in") + " " + argumentText) } - @NotNull - public WhenBuilder range(@Nullable JetExpression argument, boolean negated) { - return range(JetPsiUtil.getText(argument), negated); + public fun range(argument: JetExpression?, negated: Boolean): WhenBuilder { + return range(JetPsiUtil.getText(argument), negated) } - @NotNull - public WhenBuilder branchExpression(@NotNull String expressionText) { - assert !frozen; - assert inCondition; + public fun branchExpression(expressionText: String): WhenBuilder { + assert(!frozen) + assert(inCondition) - inCondition = false; - sb.append(" -> ").append(expressionText).append("\n"); + inCondition = false + sb.append(" -> ").append(expressionText).append("\n") - return this; + return this } - @NotNull - public WhenBuilder branchExpression(@Nullable JetExpression expression) { - return branchExpression(JetPsiUtil.getText(expression)); + public fun branchExpression(expression: JetExpression?): WhenBuilder { + return branchExpression(JetPsiUtil.getText(expression)) } - @NotNull - public WhenBuilder entry(@NotNull String entryText) { - assert !frozen; - assert !inCondition; + public fun entry(entryText: String): WhenBuilder { + assert(!frozen) + assert(!inCondition) - sb.append(entryText).append("\n"); + sb.append(entryText).append("\n") - return this; + return this } - @NotNull - public WhenBuilder entry(@Nullable JetWhenEntry whenEntry) { - return entry(JetPsiUtil.getText(whenEntry)); + public fun entry(whenEntry: JetWhenEntry?): WhenBuilder { + return entry(JetPsiUtil.getText(whenEntry)) } - @NotNull - public WhenBuilder elseEntry(@NotNull String text) { - return entry("else -> " + text); + public fun elseEntry(text: String): WhenBuilder { + return entry("else -> $text") } - @NotNull - public WhenBuilder elseEntry(@Nullable JetExpression expression) { - return elseEntry(JetPsiUtil.getText(expression)); + public fun elseEntry(expression: JetExpression?): WhenBuilder { + return elseEntry(JetPsiUtil.getText(expression)) } - @NotNull - public JetWhenExpression toExpression(Project project) { + public fun toExpression(): JetWhenExpression { if (!frozen) { - sb.append("}"); - frozen = true; + sb.append("}") + frozen = true } - return (JetWhenExpression) createExpression(project, sb.toString()); + return createExpression(sb.toString()) as JetWhenExpression + } + + { + if (subjectText != null) { + sb.append("(").append(subjectText).append(") ") + } + sb.append("{\n") } } - public static class FunctionBuilder { - static enum State { - MODIFIERS, - NAME, - RECEIVER, - FIRST_PARAM, - REST_PARAMS, - TYPE_CONSTRAINTS, - BODY, + public fun WhenBuilder(): WhenBuilder { + return WhenBuilder(null: String?) + } + + public fun WhenBuilder(subject: JetExpression?): WhenBuilder { + return WhenBuilder(subject?.getText()) + } + + public class FunctionBuilder() { + enum class State { + MODIFIERS + NAME + RECEIVER + FIRST_PARAM + REST_PARAMS + TYPE_CONSTRAINTS + BODY DONE } - private final StringBuilder sb = new StringBuilder(); - private State state = State.MODIFIERS; + private val sb = StringBuilder() + private var state = State.MODIFIERS - public FunctionBuilder() { + private fun closeParams() { + assert(state == State.FIRST_PARAM || state == State.REST_PARAMS) + + sb.append(")") + + state = State.TYPE_CONSTRAINTS } - private void closeParams() { - assert state == State.FIRST_PARAM || state == State.REST_PARAMS; - - sb.append(")"); - - state = State.TYPE_CONSTRAINTS; - } - - private void placeFun() { - assert state == State.MODIFIERS; + private fun placeFun() { + assert(state == State.MODIFIERS) if (sb.length() != 0) { - sb.append(" "); + sb.append(" ") } - sb.append("fun "); + sb.append("fun ") - state = State.RECEIVER; + state = State.RECEIVER } - @NotNull - public FunctionBuilder modifier(@NotNull String modifier) { - assert state == State.MODIFIERS; + public fun modifier(modifier: String): FunctionBuilder { + assert(state == State.MODIFIERS) - sb.append(modifier); + sb.append(modifier) - return this; + return this } - @NotNull - public FunctionBuilder typeParams(@NotNull Collection values) { - placeFun(); + public fun typeParams(values: Collection): FunctionBuilder { + placeFun() if (!values.isEmpty()) { - sb.append(KotlinPackage.makeString(values, ", ", "<", "> ", -1, "")); + sb.append(values.joinToString(", ", "<", "> ", -1, "")) } - return this; + return this } - @NotNull - public FunctionBuilder receiver(@NotNull String receiverType) { - assert state == State.RECEIVER; + public fun receiver(receiverType: String): FunctionBuilder { + assert(state == State.RECEIVER) - sb.append(receiverType).append("."); - state = State.NAME; + sb.append(receiverType).append(".") + state = State.NAME - return this; + return this } - @NotNull - public FunctionBuilder name(@NotNull String name) { - assert state == State.NAME || state == State.RECEIVER; + public fun name(name: String): FunctionBuilder { + assert(state == State.NAME || state == State.RECEIVER) - sb.append(name).append("("); - state = State.FIRST_PARAM; + sb.append(name).append("(") + state = State.FIRST_PARAM - return this; + return this } - @NotNull - public FunctionBuilder param(@NotNull String name, @NotNull String type) { - assert state == State.FIRST_PARAM || state == State.REST_PARAMS; + public fun param(name: String, `type`: String): FunctionBuilder { + assert(state == State.FIRST_PARAM || state == State.REST_PARAMS) if (state == State.REST_PARAMS) { - sb.append(", "); + sb.append(", ") } - sb.append(name).append(": ").append(type); + sb.append(name).append(": ").append(`type`) if (state == State.FIRST_PARAM) { - state = State.REST_PARAMS; + state = State.REST_PARAMS } - return this; + return this } - @NotNull - public FunctionBuilder returnType(@NotNull String type) { - closeParams(); - sb.append(": ").append(type); + public fun returnType(`type`: String): FunctionBuilder { + closeParams() + sb.append(": ").append(`type`) - return this; + return this } - @NotNull - public FunctionBuilder noReturnType() { - closeParams(); + public fun noReturnType(): FunctionBuilder { + closeParams() - return this; + return this } - @NotNull - public FunctionBuilder typeConstraints(@NotNull Collection values) { - assert state == State.TYPE_CONSTRAINTS; + public fun typeConstraints(values: Collection): FunctionBuilder { + assert(state == State.TYPE_CONSTRAINTS) if (!values.isEmpty()) { - sb.append(KotlinPackage.makeString(values, ", ", " where ", "", -1, "")); + sb.append(values.joinToString(", ", " where ", "", -1, "")) } - state = State.BODY; + state = State.BODY - return this; + return this } - @NotNull - public FunctionBuilder simpleBody(@NotNull String body) { - assert state == State.BODY || state == State.TYPE_CONSTRAINTS; + public fun simpleBody(body: String): FunctionBuilder { + assert(state == State.BODY || state == State.TYPE_CONSTRAINTS) - sb.append(" = ").append(body); - state = State.DONE; + sb.append(" = ").append(body) + state = State.DONE - return this; + return this } - @NotNull - public FunctionBuilder blockBody(@NotNull String body) { - assert state == State.BODY || state == State.TYPE_CONSTRAINTS; + public fun blockBody(body: String): FunctionBuilder { + assert(state == State.BODY || state == State.TYPE_CONSTRAINTS) - sb.append(" {\n").append(body).append("\n}"); - state = State.DONE; + sb.append(" {\n").append(body).append("\n}") + state = State.DONE - return this; + return this } - @NotNull - public String toFunctionText() { + public fun toFunctionText(): String { if (state != State.DONE) { - state = State.DONE; + state = State.DONE } - return sb.toString(); + return sb.toString() } } - @NotNull - public static JetExpression createFunctionBody(Project project, @NotNull String bodyText) { - JetFunction func = createFunction(project, "fun foo() {\n" + bodyText + "\n}"); - return func.getBodyExpression(); + public fun createFunctionBody(bodyText: String): JetExpression { + return createFunction("fun foo() {\n$bodyText\n}").getBodyExpression()!! } - @NotNull - public static JetClassObject createEmptyClassObject(Project project) { - JetClass klass = createClass(project, "class foo { class object { } }"); - return klass.getClassObject(); + public fun createEmptyClassObject(): JetClassObject { + return createClass("class foo { class object { } }").getClassObject()!! } - @NotNull - public static JetBlockExpression wrapInABlock(@NotNull JetExpression expression) { - if (expression instanceof JetBlockExpression) { - return (JetBlockExpression) expression; + public fun wrapInABlock(expression: JetExpression): JetBlockExpression { + if (expression is JetBlockExpression) { + return expression as JetBlockExpression } - return BlockWrapper.create(expression); + return BlockWrapper(expression) } - private static class BlockWrapper extends JetBlockExpression implements JetPsiUtil.JetExpressionWrapper { - private final JetExpression expression; + public fun BlockWrapper(expressionToWrap: JetExpression): BlockWrapper { + val function = createFunction("fun f() { ${expressionToWrap.getText()} }") + val block = function.getBodyExpression() as JetBlockExpression + return BlockWrapper(block, expressionToWrap) + } - public static BlockWrapper create(@NotNull JetExpression expressionToWrap) { - JetNamedFunction function = createFunction(expressionToWrap.getProject(), "fun f() { " + expressionToWrap.getText() + "}"); - JetBlockExpression block = (JetBlockExpression) function.getBodyExpression(); - assert block != null; - return new BlockWrapper(block, expressionToWrap); + private inner class BlockWrapper(fakeBlockExpression: JetBlockExpression, private val expression: JetExpression) : JetBlockExpression(fakeBlockExpression.getNode()), JetPsiUtil.JetExpressionWrapper { + + override fun getStatements(): List { + return listOf(expression) } - private BlockWrapper(@NotNull JetBlockExpression fakeBlockExpression, @NotNull JetExpression expressionToWrap) { - super(fakeBlockExpression.getNode()); - this.expression = expressionToWrap; - } - - @NotNull - @Override - public List getStatements() { - return Collections.singletonList(expression); - } - - @Override - public JetExpression getBaseExpression() { - return expression; + override fun getBaseExpression(): JetExpression { + return expression } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt index 34b473827f8..b3cdd22f1de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt +++ b/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.createEmptyBody(getProject()) as JetBlockExpression + val block = JetPsiFactory(getProject()).createEmptyBody() as JetBlockExpression block.appendElement(this) return block } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java index 2577b404692..08a233c19d8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java @@ -23,7 +23,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.rendering.Renderers; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition; @@ -48,8 +47,7 @@ import javax.inject.Inject; import java.util.List; import static org.jetbrains.jet.lang.diagnostics.Errors.*; -import static org.jetbrains.jet.lang.psi.JetPsiFactory.createExpression; -import static org.jetbrains.jet.lang.psi.JetPsiFactory.createSimpleName; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage.getCalleeExpressionIfAny; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; @@ -180,9 +178,12 @@ public class DelegatedPropertyResolver { boolean hasThis = propertyDescriptor.getReceiverParameter() != null || propertyDescriptor.getExpectedThisObject() != null; List arguments = Lists.newArrayList(); - arguments.add(createExpression(project, hasThis ? "this" : "null")); + arguments.add(JetPsiFactory(project).createExpression(hasThis ? "this" : "null")); - arguments.add(createExpression(project, KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().asString() + "(\"" + propertyDescriptor.getName().asString() + "\")")); + arguments.add(JetPsiFactory(project).createExpression(KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().asString() + + "(\"" + + propertyDescriptor.getName().asString() + + "\")")); if (!isGet) { JetReferenceExpression fakeArgument = (JetReferenceExpression) createFakeExpressionOfType(expressionTypingServices.getProject(), trace, @@ -194,7 +195,7 @@ public class DelegatedPropertyResolver { } Name functionName = Name.identifier(isGet ? "get" : "set"); - JetReferenceExpression fakeCalleeExpression = createSimpleName(project, functionName.asString()); + JetReferenceExpression fakeCalleeExpression = JetPsiFactory(project).createSimpleName(functionName.asString()); ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType); Call call = CallMaker.makeCallWithExpressions(fakeCalleeExpression, receiver, null, fakeCalleeExpression, arguments, Call.CallType.DEFAULT); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java index e452431528f..3bef8a93fe4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java @@ -48,6 +48,8 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + /** * CallTransformer treats specially 'variable as function' call case, other cases keeps unchanged (base realization). * @@ -262,7 +264,7 @@ public class CallTransformer { this.outerCall = call; this.explicitExtensionReceiver = explicitExtensionReceiver; this.calleeExpressionAsThisObject = calleeExpressionAsThisObject; - this.fakeInvokeExpression = (JetSimpleNameExpression) JetPsiFactory.createExpression(call.getCallElement().getProject(), "invoke"); + this.fakeInvokeExpression = (JetSimpleNameExpression) JetPsiFactory(call.getCallElement().getProject()).createExpression( "invoke"); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index 8b865714f52..0f53bafe241 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -43,6 +43,7 @@ import java.util.Collections; import java.util.List; import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.resolve.calls.context.ContextDependency.INDEPENDENT; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; @@ -108,8 +109,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { return getTypeInfoWhenOnlyOneBranchIsPresent( elseBranch, elseScope, elseInfo, thenInfo, contextWithExpectedType, ifExpression, isStatement); } - JetBlockExpression thenBlock = JetPsiFactory.wrapInABlock(thenBranch); - JetBlockExpression elseBlock = JetPsiFactory.wrapInABlock(elseBranch); + JetBlockExpression thenBlock = JetPsiFactory(ifExpression.getProject()).wrapInABlock(thenBranch); + JetBlockExpression elseBlock = JetPsiFactory(ifExpression.getProject()).wrapInABlock(elseBranch); Call callForIf = createCallForSpecialConstruction(ifExpression, ifExpression, Lists.newArrayList(thenBlock, elseBlock)); MutableDataFlowInfoForArguments dataFlowInfoForArguments = createDataFlowInfoForArgumentsForIfCall(callForIf, thenInfo, elseInfo); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 1e48e6a41fb..80be5d9c82b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -57,6 +57,7 @@ import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.*; import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.types.TypeUtils.noExpectedType; @@ -220,7 +221,7 @@ public class ExpressionTypingUtils { @NotNull JetScope scope, @NotNull ModuleDescriptor module ) { - JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, callableFQN.asString()); + JetImportDirective importDirective = JetPsiFactory(project).createImportDirective(callableFQN.asString()); Collection declarationDescriptors = new QualifiedExpressionResolver() .analyseImportReference(importDirective, scope, new BindingTraceContext(), module); @@ -332,7 +333,7 @@ public class ExpressionTypingUtils { @NotNull String argumentName, @NotNull JetType argumentType ) { - JetExpression fakeExpression = JetPsiFactory.createExpression(project, argumentName); + JetExpression fakeExpression = JetPsiFactory(project).createExpression(argumentName); trace.record(EXPRESSION_TYPE, fakeExpression, argumentType); trace.record(PROCESSED, fakeExpression); return fakeExpression; @@ -364,7 +365,7 @@ public class ExpressionTypingUtils { @NotNull List valueArguments, @NotNull Name name ) { - final JetReferenceExpression fake = JetPsiFactory.createSimpleName(expressionTypingServices.getProject(), "fake"); + final JetReferenceExpression fake = JetPsiFactory(expressionTypingServices.getProject()).createSimpleName("fake"); TemporaryBindingTrace fakeTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve fake call for", name); Call call = CallMaker.makeCallWithExpressions(fake, receiver, null, fake, valueArguments); OverloadResolutionResults results = diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ForLoopConventionsChecker.java index 46883127ec1..b28d891e54f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ForLoopConventionsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ForLoopConventionsChecker.java @@ -25,7 +25,6 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory1; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; @@ -42,6 +41,7 @@ import javax.inject.Inject; import java.util.Collections; import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.isBoolean; @@ -67,7 +67,7 @@ public class ForLoopConventionsChecker { } public boolean isVariableIterable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope) { - JetExpression expression = JetPsiFactory.createExpression(project, "fake"); + JetExpression expression = JetPsiFactory(project).createExpression("fake"); ExpressionReceiver expressionReceiver = new ExpressionReceiver(expression, variableDescriptor.getType()); ExpressionTypingContext context = ExpressionTypingContext.newContext( expressionTypingServices, diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 7d354827c84..03ae167b966 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -58,7 +58,6 @@ import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.diagnostics.Severity; import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil; @@ -92,6 +91,7 @@ import static org.jetbrains.jet.ConfigurationKind.JDK_AND_ANNOTATIONS; import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY; import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalyzeExhaust; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; public class JetTestUtils { private static final Pattern KT_FILES = Pattern.compile(".*?.kt"); @@ -812,7 +812,7 @@ public class JetTestUtils { public static JetFile loadJetFile(@NotNull Project project, @NotNull File ioFile) throws IOException { String text = FileUtil.loadFile(ioFile, true); - return JetPsiFactory.createPhysicalFile(project, ioFile.getName(), text); + return JetPsiFactory(project).createPhysicalFile(ioFile.getName(), text); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java b/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java index d14e2e3c39f..4b93eb7e21a 100644 --- a/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java @@ -32,6 +32,8 @@ import java.util.Collection; import java.util.regex.Matcher; import java.util.regex.Pattern; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetPsiUtilTest extends JetLiteFixture { public void testUnquotedIdentifier() { Assert.assertEquals("", JetPsiUtil.unquoteIdentifier("")); @@ -70,7 +72,7 @@ public class JetPsiUtilTest extends JetLiteFixture { public void testIsLocalClass() throws IOException { String text = FileUtil.loadFile(new File(getTestDataPath() + "/psiUtil/isLocalClass.kt"), true); - JetClass aClass = JetPsiFactory.createClass(getProject(), text); + JetClass aClass = JetPsiFactory(getProject()).createClass(text); @SuppressWarnings("unchecked") Collection classOrObjects = PsiTreeUtil.collectElementsOfType(aClass, JetClassOrObject.class); @@ -101,7 +103,7 @@ public class JetPsiUtilTest extends JetLiteFixture { private ImportPath getImportPathFromParsed(String text) { JetImportDirective importDirective = - PsiTreeUtil.findChildOfType(JetPsiFactory.createFile(getProject(), text), JetImportDirective.class); + PsiTreeUtil.findChildOfType(JetPsiFactory(getProject()).createFile(text), JetImportDirective.class); assertNotNull("At least one import directive is expected", importDirective); diff --git a/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt b/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt index d3050d05ef3..be97e73f010 100644 --- a/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt +++ b/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt @@ -31,7 +31,7 @@ public class JetSimpleNameExpressionTest() : JetLiteFixture() { assertReceiver("1 to 2", "1") } private fun assertReceiver(exprString: String, expected: String) { - val expression = JetPsiFactory.createExpression(getProject(), exprString) as JetBinaryExpression + val expression = JetPsiFactory(getProject()).createExpression(exprString) as JetBinaryExpression Assert.assertEquals(expected, expression.getOperationReference().getReceiverExpression()!!.getText()) } override fun createEnvironment(): JetCoreEnvironment { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 9a1937769fd..81a7334ad0e 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -44,6 +44,8 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTestWithEnvironment { @Override protected JetCoreEnvironment createEnvironment() { @@ -57,7 +59,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe protected void doTest(@NotNull String testFile) throws IOException { String fileText = FileUtil.loadFile(new File(testFile), true); - JetFile psiFile = JetPsiFactory.createFile(getProject(), fileText); + JetFile psiFile = JetPsiFactory(getProject()).createFile(fileText); Collection files = Lists.newArrayList(psiFile); final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveRecursiveComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveRecursiveComparingTest.java index 6ffa72b79c6..8fdfee12e29 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveRecursiveComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveRecursiveComparingTest.java @@ -24,7 +24,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.test.util.RecursiveDescriptorComparator; @@ -35,6 +34,7 @@ import java.io.IOException; import java.util.List; import java.util.Map; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES; import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.FORBID_ERROR_TYPES; @@ -63,7 +63,7 @@ public abstract class AbstractLazyResolveRecursiveComparingTest extends KotlinTe new JetTestUtils.TestFileFactoryNoModules() { @Override public JetFile create(String fileName, String text, Map directives) { - return JetPsiFactory.createFile(getProject(), fileName, text); + return JetPsiFactory(getProject()).createFile(fileName, text); } }); diff --git a/compiler/tests/org/jetbrains/jet/parsing/AbstractJetParsingTest.java b/compiler/tests/org/jetbrains/jet/parsing/AbstractJetParsingTest.java index 06c30f62672..66992a5a585 100644 --- a/compiler/tests/org/jetbrains/jet/parsing/AbstractJetParsingTest.java +++ b/compiler/tests/org/jetbrains/jet/parsing/AbstractJetParsingTest.java @@ -36,6 +36,8 @@ import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public abstract class AbstractJetParsingTest extends ParsingTestCase { static { System.setProperty("idea.platform.prefix", "Idea"); @@ -108,11 +110,12 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase { } private PsiFile createFile(@NotNull String filePath, @NotNull IElementType fileType) throws Exception { + JetPsiFactory psiFactory = JetPsiFactory(myProject); if (fileType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT) { - return JetPsiFactory.createExpressionCodeFragment(myProject, loadFile(filePath), null); + return psiFactory.createExpressionCodeFragment(loadFile(filePath), null); } else if (fileType == JetNodeTypes.BLOCK_CODE_FRAGMENT) { - return JetPsiFactory.createBlockCodeFragment(myProject, loadFile(filePath), null); + return psiFactory.createBlockCodeFragment(loadFile(filePath), null); } else { return createPsiFile(FileUtil.getNameWithoutExtension(PathUtil.getFileName(filePath)), loadFile(filePath)); diff --git a/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt index 6ec34f96a1c..1cdd77fb1b1 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt @@ -45,7 +45,7 @@ public abstract class AbstractResolvedCallsTest() : JetLiteFixture() { public fun doTest(filePath: String) { val text = JetTestUtils.doLoadFile(File(filePath))!! - val jetFile = JetPsiFactory.createFile(getProject(), text.replace("", "")) + val jetFile = JetPsiFactory(getProject()).createFile(text.replace("", "")) val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(jetFile).getBindingContext() val element = jetFile.findElementAt(text.indexOf("")) diff --git a/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt b/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt index cd61efd11f1..cab51ef5bd9 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt @@ -70,7 +70,7 @@ public class MyDeclarations( return JetTypeImpl(Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong()), false, listOf(), JetScope.EMPTY) } return typeResolver.resolveType( - scopeToResolveTypeParameters, JetPsiFactory.createType(project, name), + scopeToResolveTypeParameters, JetPsiFactory(project).createType(name), JetTestUtils.DUMMY_TRACE, true) } } diff --git a/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java b/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java index f348090e4f0..4e60051cc8a 100644 --- a/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java @@ -22,7 +22,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment; import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -33,6 +32,8 @@ import org.jetbrains.jet.renderer.DescriptorRenderer; import java.util.Collection; import java.util.Collections; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class BoundsSubstitutorTest extends KotlinTestWithEnvironment { @Override protected JetCoreEnvironment createEnvironment() { @@ -70,7 +71,7 @@ public class BoundsSubstitutorTest extends KotlinTestWithEnvironment { //} private void doTest(String text, String expected) { - JetFile jetFile = JetPsiFactory.createFile(getProject(), "fun.kt", text); + JetFile jetFile = JetPsiFactory(getProject()).createFile("fun.kt", text); ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment()); Collection functions = module.getPackage(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f")); assert functions.size() == 1 : "Many functions defined"; diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index d45b4923046..086af96c381 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -43,6 +43,8 @@ import org.jetbrains.jet.storage.LockBasedStorageManager; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetDefaultModalityModifiersTest extends JetLiteFixture { private final JetDefaultModalityModifiersTestCase tc = new JetDefaultModalityModifiersTestCase(); @@ -80,7 +82,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { } private JetScope createScope(JetScope libraryScope) { - JetFile file = JetPsiFactory.createFile(getProject(), "abstract class C { abstract fun foo(); abstract val a: Int }"); + JetFile file = JetPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }"); List declarations = file.getDeclarations(); JetDeclaration aClass = declarations.get(0); assert aClass instanceof JetClass; @@ -106,7 +108,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { } private void testClassModality(String classDeclaration, ClassKind kind, Modality expectedModality) { - JetClass aClass = JetPsiFactory.createClass(getProject(), classDeclaration); + JetClass aClass = JetPsiFactory(getProject()).createClass(classDeclaration); ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass); assertEquals(expectedModality, classDescriptor.getModality()); @@ -114,7 +116,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private void testFunctionModality(String classWithFunction, ClassKind kind, Modality expectedFunctionModality) { - JetClass aClass = JetPsiFactory.createClass(getProject(), classWithFunction); + JetClass aClass = JetPsiFactory(getProject()).createClass(classWithFunction); ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass); List declarations = aClass.getDeclarations(); @@ -127,7 +129,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { } private void testPropertyModality(String classWithProperty, ClassKind kind, Modality expectedPropertyModality) { - JetClass aClass = JetPsiFactory.createClass(getProject(), classWithProperty); + JetClass aClass = JetPsiFactory(getProject()).createClass(classWithProperty); ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass); List declarations = aClass.getDeclarations(); @@ -140,7 +142,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private void testPropertyAccessorModality(String classWithPropertyWithAccessor, ClassKind kind, Modality expectedPropertyAccessorModality, boolean isGetter) { - JetClass aClass = JetPsiFactory.createClass(getProject(), classWithPropertyWithAccessor); + JetClass aClass = JetPsiFactory(getProject()).createClass(classWithPropertyWithAccessor); ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass); List declarations = aClass.getDeclarations(); diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java index 46823f371bf..dad812eed3e 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java @@ -25,12 +25,13 @@ import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.OverloadUtil; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetOverloadTest extends JetLiteFixture { private ModuleDescriptor root = JetTestUtils.createEmptyModule(""); @@ -178,7 +179,7 @@ public class JetOverloadTest extends JetLiteFixture { } private FunctionDescriptor makeFunction(String funDecl) { - JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl); + JetNamedFunction function = JetPsiFactory(getProject()).createFunction(funDecl); return descriptorResolver.resolveFunctionDescriptor(root, KotlinBuiltIns.getInstance().getBuiltInsPackageScope(), function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java index 48cb58b748b..e773050123f 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java @@ -25,12 +25,13 @@ import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.OverridingUtil; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetOverridingTest extends JetLiteFixture { private ModuleDescriptor root = JetTestUtils.createEmptyModule(""); @@ -168,7 +169,7 @@ public class JetOverridingTest extends JetLiteFixture { } private FunctionDescriptor makeFunction(String funDecl) { - JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl); + JetNamedFunction function = JetPsiFactory(getProject()).createFunction(funDecl); return descriptorResolver.resolveFunctionDescriptor(root, KotlinBuiltIns.getInstance().getBuiltInsPackageScope(), function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 6053bfc3ba6..7053ddbc447 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -35,7 +35,6 @@ import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.TypeResolver; @@ -56,6 +55,8 @@ import java.io.File; import java.io.IOException; import java.util.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetTypeCheckerTest extends JetLiteFixture { private KotlinBuiltIns builtIns; @@ -533,14 +534,14 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertType(String expression, JetType expectedType) { Project project = getProject(); - JetExpression jetExpression = JetPsiFactory.createExpression(project, expression); + JetExpression jetExpression = JetPsiFactory(project).createExpression(expression); JetType type = expressionTypingServices.getType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE); assertTrue(type + " != " + expectedType, type.equals(expectedType)); } private void assertErrorType(String expression) { Project project = getProject(); - JetExpression jetExpression = JetPsiFactory.createExpression(project, expression); + JetExpression jetExpression = JetPsiFactory(project).createExpression(expression); JetType type = expressionTypingServices.safeGetType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE); assertTrue("Error type expected but " + type + " returned", type.isError()); } @@ -560,7 +561,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { return Lists.newArrayList(new ReceiverParameterDescriptorImpl( getContainingDeclaration(), thisType, - new ExpressionReceiver(JetPsiFactory.createExpression(getProject(), expression), thisType) + new ExpressionReceiver(JetPsiFactory(getProject()).createExpression(expression), thisType) )); } }; @@ -573,7 +574,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertType(JetScope scope, String expression, String expectedTypeStr) { Project project = getProject(); - JetExpression jetExpression = JetPsiFactory.createExpression(project, expression); + JetExpression jetExpression = JetPsiFactory(project).createExpression(expression); JetType type = expressionTypingServices.getType( addImports(scope), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, new BindingTraceContext()); JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr); @@ -613,6 +614,6 @@ public class JetTypeCheckerTest extends JetLiteFixture { } private JetType makeType(JetScope scope, String typeStr) { - return typeResolver.resolveType(scope, JetPsiFactory.createType(getProject(), typeStr), JetTestUtils.DUMMY_TRACE, true); + return typeResolver.resolveType(scope, JetPsiFactory(getProject()).createType(typeStr), JetTestUtils.DUMMY_TRACE, true); } } diff --git a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java index e9e04dfba0e..ffd91a00e7e 100644 --- a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java @@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetTypeReference; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -53,6 +52,8 @@ import java.io.IOException; import java.util.Collections; import java.util.Map; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + @SuppressWarnings("unchecked") public class TypeSubstitutorTest extends KotlinTestWithEnvironment { private JetScope scope; @@ -81,7 +82,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { private JetScope getContextScope() throws IOException { // todo comments String text = FileUtil.loadFile(new File("compiler/testData/type-substitutor.kt"), true); - JetFile jetFile = JetPsiFactory.createFile(getProject(), text); + JetFile jetFile = JetPsiFactory(getProject()).createFile(text); ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment()); JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope(); ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context")); @@ -137,7 +138,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { } private JetType resolveType(String typeStr) { - JetTypeReference jetTypeReference = JetPsiFactory.createType(getProject(), typeStr); + JetTypeReference jetTypeReference = JetPsiFactory(getProject()).createType(typeStr); AnalyzingUtils.checkForSyntacticErrors(jetTypeReference); BindingTrace trace = new BindingTraceContext(); JetType type = injector.getTypeResolver().resolveType(scope, jetTypeReference, trace, true); diff --git a/compiler/tests/org/jetbrains/jet/types/TypeUnifierTest.java b/compiler/tests/org/jetbrains/jet/types/TypeUnifierTest.java index b860cf3b9bc..734edf7ff69 100644 --- a/compiler/tests/org/jetbrains/jet/types/TypeUnifierTest.java +++ b/compiler/tests/org/jetbrains/jet/types/TypeUnifierTest.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetTypeProjection; import org.jetbrains.jet.lang.psi.JetTypeReference; import org.jetbrains.jet.lang.resolve.TypeResolver; @@ -44,6 +43,8 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Map; import java.util.Set; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class TypeUnifierTest extends JetLiteFixture { private Set variables; @@ -207,7 +208,7 @@ public class TypeUnifierTest extends JetLiteFixture { withX.addClassifierDescriptor(y); withX.changeLockLevel(WritableScope.LockLevel.READING); - JetTypeProjection projection = JetPsiFactory.createTypeArguments(getProject(), "<" + typeStr + ">").getArguments().get(0); + JetTypeProjection projection = JetPsiFactory(getProject()).createTypeArguments("<" + typeStr + ">").getArguments().get(0); JetTypeReference typeReference = projection.getTypeReference(); assert typeReference != null; diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java b/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java index 7eb504d3cf6..fe79b7ed288 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java @@ -33,10 +33,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.Modality; -import org.jetbrains.jet.lang.psi.JetClass; -import org.jetbrains.jet.lang.psi.JetClassBody; -import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetBundle; @@ -85,11 +82,12 @@ public class JetAddFunctionToClassifierAction implements QuestionAction { ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { + JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project); JetClassBody body = classifierDeclaration.getBody(); if (body == null) { - PsiElement whitespaceBefore = classifierDeclaration.add(JetPsiFactory.createWhiteSpace(project)); - body = (JetClassBody) classifierDeclaration.addAfter(JetPsiFactory.createEmptyClassBody(project), whitespaceBefore); - classifierDeclaration.addAfter(JetPsiFactory.createNewLine(project), body); + PsiElement whitespaceBefore = classifierDeclaration.add(psiFactory.createWhiteSpace()); + body = (JetClassBody) classifierDeclaration.addAfter(psiFactory.createEmptyClassBody(), whitespaceBefore); + classifierDeclaration.addAfter(psiFactory.createNewLine(), body); } String functionBody = ""; @@ -100,7 +98,7 @@ public class JetAddFunctionToClassifierAction implements QuestionAction { functionBody = "{ throw UnsupportedOperationException() }"; } } - JetNamedFunction functionElement = JetPsiFactory.createFunction(project, signatureString + functionBody); + JetNamedFunction functionElement = psiFactory.createFunction(signatureString + functionBody); PsiElement anchor = body.getRBrace(); JetNamedFunction insertedFunctionElement = (JetNamedFunction) body.addBefore(functionElement, anchor); diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JetChangeFunctionSignatureAction.java b/idea/src/org/jetbrains/jet/plugin/actions/JetChangeFunctionSignatureAction.java index 54dd1bbafb2..3b4465cdcdd 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JetChangeFunctionSignatureAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JetChangeFunctionSignatureAction.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.psi.PsiPackage; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils; import org.jetbrains.jet.plugin.codeInsight.ShortenReferences; @@ -38,7 +39,6 @@ import org.jetbrains.jet.plugin.codeInsight.ShortenReferences; import javax.swing.*; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.List; /** @@ -126,6 +126,7 @@ public class JetChangeFunctionSignatureAction implements QuestionAction { PsiDocumentManager.getInstance(project).commitAllDocuments(); + final JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project); CommandProcessor.getInstance().executeCommand(project, new Runnable() { @Override public void run() { @@ -137,17 +138,17 @@ public class JetChangeFunctionSignatureAction implements QuestionAction { if (bodyExpression != null) { if (element.hasBlockBody()) { - newElement = JetPsiFactory.createFunction(project, signatureString + "{}"); + newElement = psiFactory.createFunction(signatureString + "{}"); } else { - newElement = JetPsiFactory.createFunction(project, signatureString + "= \"dummy\""); + newElement = psiFactory.createFunction(signatureString + "= \"dummy\""); } JetExpression newBodyExpression = newElement.getBodyExpression(); assert newBodyExpression != null; newBodyExpression.replace(bodyExpression); } else { - newElement = JetPsiFactory.createFunction(project, signatureString); + newElement = psiFactory.createFunction(signatureString); } newElement = (JetNamedFunction) element.replace(newElement); ShortenReferences.instance$.process(newElement); diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java index 181cf4bc31c..565e30ed451 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java @@ -54,6 +54,7 @@ import org.jetbrains.jet.plugin.stubindex.*; import java.util.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.plugin.caches.JetFromJavaDescriptorHelper.getTopLevelFunctionFqNames; /** @@ -243,7 +244,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { } }); for (FqName fqName : topLevelFunctionFqNames) { - JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, new ImportPath(fqName, false)); + JetImportDirective importDirective = JetPsiFactory(project).createImportDirective(new ImportPath(fqName, false)); Collection declarationDescriptors = new QualifiedExpressionResolver().analyseImportReference( importDirective, jetScope, new BindingTraceContext(), resolveSession.getModuleDescriptor()); for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) { diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt index 087c3b91ce4..d66b0007e0c 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt @@ -57,10 +57,8 @@ import com.intellij.openapi.diagnostic.Logger import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression import org.jetbrains.jet.lang.psi.JetUserType import org.jetbrains.jet.lang.psi.JetTypeReference -import com.intellij.util.containers.ContainerUtil import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils import org.jetbrains.jet.plugin.imports.* -import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor import org.jetbrains.jet.lang.psi.psiUtil.getReceiverExpression import org.jetbrains.jet.utils.* @@ -314,7 +312,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor().getSimpleName()}." @@ -335,7 +333,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor()) 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.createType(project, "$prefixToInsert.${typeReference.getText()}")) + typeReference!!.replace(JetPsiFactory(project).createType("$prefixToInsert.${typeReference.getText()}")) } else { expression.replace(createQualifiedExpression(project, fqName.asString())) diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java index 55c0966cac8..4f0baba5547 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java @@ -45,6 +45,8 @@ import java.util.Collections; import java.util.List; import java.util.Set; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public abstract class OverrideImplementMethodsHandler implements LanguageCodeInsightActionHandler { private static final DescriptorRenderer OVERRIDE_RENDERER = new DescriptorRendererBuilder() @@ -81,8 +83,9 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns JetClassBody body = classOrObject.getBody(); if (body == null) { Project project = classOrObject.getProject(); - classOrObject.add(JetPsiFactory.createWhiteSpace(project)); - body = (JetClassBody) classOrObject.add(JetPsiFactory.createEmptyClassBody(project)); + JetPsiFactory psiFactory = JetPsiFactory(project); + classOrObject.add(psiFactory.createWhiteSpace()); + body = (JetClassBody) classOrObject.add(psiFactory.createEmptyClassBody()); } PsiElement afterAnchor = findInsertAfterAnchor(editor, body); @@ -162,7 +165,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns else { body.append(initializer); } - return JetPsiFactory.createProperty(project, OVERRIDE_RENDERER.render(newDescriptor) + body); + return JetPsiFactory(project).createProperty(OVERRIDE_RENDERER.render(newDescriptor) + body); } @NotNull @@ -201,7 +204,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns boolean returnsNotUnit = returnType != null && !builtIns.getUnitType().equals(returnType); String body = "{" + (returnsNotUnit && !isAbstractFun ? "return " : "") + delegationBuilder.toString() + "}"; - return JetPsiFactory.createFunction(project, OVERRIDE_RENDERER.render(newDescriptor) + body); + return JetPsiFactory(project).createFunction(OVERRIDE_RENDERER.render(newDescriptor) + body); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt b/idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt index 0523edacb71..881120ece6c 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt +++ b/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.createType(userType.getProject(), text).getTypeElement()!! + val newUserType = JetPsiFactory(userType.getProject()).createType(text).getTypeElement()!! userType.replace(newUserType) } } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/MoveDeclarationsOutHelper.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/MoveDeclarationsOutHelper.java index bb25ae33962..06364c13228 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/MoveDeclarationsOutHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/MoveDeclarationsOutHelper.java @@ -37,8 +37,7 @@ import org.jetbrains.jet.renderer.DescriptorRenderer; import java.util.ArrayList; import java.util.List; -import static org.jetbrains.jet.lang.psi.JetPsiFactory.createExpression; -import static org.jetbrains.jet.lang.psi.JetPsiFactory.createNewLine; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; public class MoveDeclarationsOutHelper { @@ -53,7 +52,8 @@ public class MoveDeclarationsOutHelper { List propertiesDeclarations = new ArrayList(); // Dummy element to add new declarations at the beginning - PsiElement dummyFirstStatement = container.addBefore(createExpression(project, "dummyStatement "), statements[0]); + JetPsiFactory psiFactory = JetPsiFactory(project); + PsiElement dummyFirstStatement = container.addBefore(psiFactory.createExpression("dummyStatement "), statements[0]); try { SearchScope scope = new LocalSearchScope(container); @@ -66,14 +66,14 @@ public class MoveDeclarationsOutHelper { JetProperty declaration = createVariableDeclaration(property, generateDefaultInitializers); declaration = (JetProperty) container.addBefore(declaration, dummyFirstStatement); propertiesDeclarations.add(declaration); - container.addAfter(createNewLine(project), declaration); + container.addAfter(psiFactory.createNewLine(), declaration); JetBinaryExpression assignment = createVariableAssignment(property); resultStatements.add(property.replace(assignment)); } else { PsiElement newStatement = container.addBefore(statement, dummyFirstStatement); - container.addAfter(createNewLine(project), newStatement); + container.addAfter(psiFactory.createNewLine(), newStatement); container.deleteChildRange(statement, statement); } } @@ -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) createExpression(property.getProject(), propertyName + " = x"); + JetBinaryExpression assignment = (JetBinaryExpression) JetPsiFactory(property.getProject()).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.createProperty(property.getProject(), property.getName(), typeString, property.isVar(), initializer); + return JetPsiFactory(property.getProject()).createProperty(property.getName(), typeString, property.isVar(), initializer); } private static boolean needToDeclareOut(@NotNull PsiElement element, int lastStatementOffset, @NotNull SearchScope scope) { diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinNotSurrounder.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinNotSurrounder.java index 498b5a84d6c..c18571d017d 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinNotSurrounder.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinNotSurrounder.java @@ -26,11 +26,12 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetParenthesizedExpression; import org.jetbrains.jet.lang.psi.JetPrefixExpression; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.codeInsight.surroundWith.KotlinSurrounderUtils; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class KotlinNotSurrounder extends KotlinExpressionSurrounder { @Override public String getTemplateDescription() { @@ -46,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.createExpression(project, "!(a)"); + JetPrefixExpression prefixExpr = (JetPrefixExpression) JetPsiFactory(project).createExpression("!(a)"); JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) prefixExpr.getBaseExpression(); assert parenthesizedExpression != null : "JetParenthesizedExpression should exists for " + prefixExpr.getText() + " expression"; JetExpression expressionWithoutParentheses = parenthesizedExpression.getExpression(); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java index 118424fdbb2..d7f86bde3b3 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java @@ -25,7 +25,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetParenthesizedExpression; -import org.jetbrains.jet.lang.psi.JetPsiFactory; + +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; public class KotlinParenthesesSurrounder extends KotlinExpressionSurrounder { @Override @@ -41,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.createExpression(project, "(a)"); + JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) JetPsiFactory(project).createExpression("(a)"); JetExpression expressionWithoutParentheses = parenthesizedExpression.getExpression(); assert expressionWithoutParentheses != null : "JetExpression should exists for " + parenthesizedExpression.getText() + " expression"; expressionWithoutParentheses.replace(expression); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java index 19e64c7429d..b2a6c1961fd 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java @@ -22,9 +22,14 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.TextRange; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetConstantExpression; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetStringTemplateEntry; +import org.jetbrains.jet.lang.psi.JetStringTemplateExpression; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class KotlinStringTemplateSurrounder extends KotlinExpressionSurrounder { @Override public String getTemplateDescription() { @@ -39,7 +44,9 @@ public class KotlinStringTemplateSurrounder extends KotlinExpressionSurrounder { @Nullable @Override public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) { - JetStringTemplateExpression stringTemplateExpression = (JetStringTemplateExpression)JetPsiFactory.createExpression(project, getCodeTemplate(expression)); + JetStringTemplateExpression stringTemplateExpression = (JetStringTemplateExpression) JetPsiFactory(project).createExpression( + getCodeTemplate(expression) + ); JetStringTemplateEntry templateEntry = stringTemplateExpression.getEntries()[0]; JetExpression innerExpression = templateEntry.getExpression(); assert innerExpression != null : "JetExpression should exists for " + stringTemplateExpression.toString(); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java index 1ec72e2617f..26a848ec469 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java @@ -25,11 +25,16 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetWhenCondition; +import org.jetbrains.jet.lang.psi.JetWhenEntry; +import org.jetbrains.jet.lang.psi.JetWhenExpression; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.codeInsight.surroundWith.KotlinSurrounderUtils; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class KotlinWhenSurrounder extends KotlinExpressionSurrounder { @Override public String getTemplateDescription() { @@ -44,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.createExpression(project, getCodeTemplate(expression)); + JetWhenExpression whenExpression = (JetWhenExpression) JetPsiFactory(project).createExpression(getCodeTemplate(expression)); JetExpression subjectExpression = whenExpression.getSubjectExpression(); assert subjectExpression != null : "JetExpression should exists for " + whenExpression.getText() + " expression"; subjectExpression.replace(expression); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java index 5aecec4434b..b7e34dfdcae 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java @@ -27,6 +27,8 @@ import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.codeInsight.surroundWith.KotlinSurrounderUtils; import org.jetbrains.jet.plugin.codeInsight.surroundWith.MoveDeclarationsOutHelper; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class KotlinFunctionLiteralSurrounder extends KotlinStatementsSurrounder { @Nullable @Override @@ -38,9 +40,10 @@ public class KotlinFunctionLiteralSurrounder extends KotlinStatementsSurrounder return null; } - JetCallExpression callExpression = (JetCallExpression) JetPsiFactory.createExpression(project, "run {\n}"); + JetPsiFactory psiFactory = JetPsiFactory(project); + JetCallExpression callExpression = (JetCallExpression) psiFactory.createExpression("run {\n}"); callExpression = (JetCallExpression) container.addAfter(callExpression, statements[statements.length - 1]); - container.addBefore(JetPsiFactory.createWhiteSpace(project), callExpression); + container.addBefore(psiFactory.createWhiteSpace(), callExpression); JetFunctionLiteralExpression bodyExpression = (JetFunctionLiteralExpression) callExpression.getFunctionLiteralArguments().get(0); assert bodyExpression != null : "Body expression should exists for " + callExpression.getText(); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java index b1c3e181b3b..0bb13aaae04 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java @@ -27,10 +27,11 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetBlockExpression; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetIfExpression; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.plugin.codeInsight.surroundWith.KotlinSurrounderUtils; import org.jetbrains.jet.plugin.codeInsight.surroundWith.MoveDeclarationsOutHelper; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public abstract class KotlinIfSurrounderBase extends KotlinStatementsSurrounder { @Nullable @@ -43,7 +44,7 @@ public abstract class KotlinIfSurrounderBase extends KotlinStatementsSurrounder return null; } - JetIfExpression ifExpression = (JetIfExpression) JetPsiFactory.createExpression(project, getCodeTemplate()); + JetIfExpression ifExpression = (JetIfExpression) JetPsiFactory(project).createExpression(getCodeTemplate()); ifExpression = (JetIfExpression) container.addAfter(ifExpression, statements[statements.length - 1]); // TODO move a comment for first statement diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java index f949d3d41ea..ca8b0d67954 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java @@ -23,10 +23,15 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetBlockExpression; +import org.jetbrains.jet.lang.psi.JetElement; +import org.jetbrains.jet.lang.psi.JetParameter; +import org.jetbrains.jet.lang.psi.JetTryExpression; import org.jetbrains.jet.plugin.codeInsight.surroundWith.KotlinSurrounderUtils; import org.jetbrains.jet.plugin.codeInsight.surroundWith.MoveDeclarationsOutHelper; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public abstract class KotlinTrySurrounderBase extends KotlinStatementsSurrounder { @Nullable @@ -39,7 +44,7 @@ public abstract class KotlinTrySurrounderBase extends KotlinStatementsSurrounder return null; } - JetTryExpression tryExpression = (JetTryExpression) JetPsiFactory.createExpression(project, getCodeTemplate()); + JetTryExpression tryExpression = (JetTryExpression) JetPsiFactory(project).createExpression(getCodeTemplate()); tryExpression = (JetTryExpression) container.addAfter(tryExpression, statements[statements.length - 1]); // TODO move a comment for first statement diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/unwrap/KotlinUnwrappers.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/unwrap/KotlinUnwrappers.java index c3f18edd16c..c95a4bcf976 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/unwrap/KotlinUnwrappers.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/unwrap/KotlinUnwrappers.java @@ -22,6 +22,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class KotlinUnwrappers { private KotlinUnwrappers() { } @@ -72,7 +74,7 @@ public class KotlinUnwrappers { @Override protected void doUnwrap(PsiElement element, Context context) throws IncorrectOperationException { JetIfExpression ifExpr = (JetIfExpression) element; - context.replace(ifExpr, JetPsiFactory.createIf(ifExpr.getProject(), ifExpr.getCondition(), ifExpr.getThen(), null)); + context.replace(ifExpr, JetPsiFactory(ifExpr.getProject()).createIf(ifExpr.getCondition(), ifExpr.getThen(), null)); } } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/upDownMover/JetExpressionMover.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/upDownMover/JetExpressionMover.java index 7e1c6337eda..1b23052ea3d 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/upDownMover/JetExpressionMover.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/upDownMover/JetExpressionMover.java @@ -34,6 +34,8 @@ import org.jetbrains.jet.lexer.JetTokens; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetExpressionMover extends AbstractJetUpDownMover { private static final Predicate IS_CALL_EXPRESSION = new Predicate() { @@ -549,7 +551,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover { PsiElement parent = element.getParent(); assert parent != null; - parent.addAfter(JetPsiFactory.createComma(parent.getProject()), element); + parent.addAfter(JetPsiFactory(parent.getProject()).createComma(), element); } } diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/extractFunctionForDebuggerUtil.kt b/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/extractFunctionForDebuggerUtil.kt index 745a9c8e795..75e04693c0a 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/extractFunctionForDebuggerUtil.kt +++ b/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/extractFunctionForDebuggerUtil.kt @@ -110,14 +110,15 @@ private fun addImportsToFile(newImportList: JetImportList?, tmpFile: JetFile) { if (newImportList != null) { val tmpFileImportList = tmpFile.getImportList() val packageDirective = tmpFile.getPackageDirective() + val psiFactory = JetPsiFactory(tmpFile.getProject()) if (tmpFileImportList == null) { - tmpFile.addAfter(JetPsiFactory.createNewLine(tmpFile.getProject()), packageDirective) + tmpFile.addAfter(psiFactory.createNewLine(), packageDirective) tmpFile.addAfter(newImportList, tmpFile.getPackageDirective()) } else { tmpFileImportList.replace(newImportList) } - tmpFile.addAfter(JetPsiFactory.createNewLine(tmpFile.getProject()), packageDirective) + tmpFile.addAfter(psiFactory.createNewLine(), packageDirective) } } @@ -125,7 +126,8 @@ private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment val parent = contextElement.getParent() if (parent == null) return null - parent.addBefore(JetPsiFactory.createNewLine(contextElement.getProject()), contextElement) + val psiFactory = JetPsiFactory(contextElement.getProject()) + parent.addBefore(psiFactory.createNewLine(), contextElement) val debugExpression = codeFragment.getContentElement() if (debugExpression == null) return null @@ -133,7 +135,7 @@ private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment val newDebugExpression = parent.addBefore(debugExpression, contextElement) if (newDebugExpression == null) return null - parent.addBefore(JetPsiFactory.createNewLine(contextElement.getProject()), contextElement) + parent.addBefore(psiFactory.createNewLine(), contextElement) return newDebugExpression as JetExpression } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/AddBracesIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/AddBracesIntention.kt index b1fe96929b8..76dae44934e 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/AddBracesIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/AddBracesIntention.kt @@ -16,17 +16,9 @@ package org.jetbrains.jet.plugin.intentions -import org.jetbrains.jet.lang.psi.JetIfExpression -import org.jetbrains.jet.lang.psi.JetWhileExpression -import org.jetbrains.jet.lang.psi.JetForExpression -import org.jetbrains.jet.lang.psi.JetDoWhileExpression import org.jetbrains.jet.lang.psi.JetExpressionImpl import org.jetbrains.jet.lang.psi.JetPsiFactory -import org.jetbrains.jet.lang.psi.JetBlockExpression -import com.intellij.psi.PsiElement -import com.intellij.openapi.project.Project import com.intellij.openapi.editor.Editor -import com.intellij.psi.PsiFile import com.intellij.lang.ASTNode import org.jetbrains.jet.JetNodeTypes import com.intellij.psi.PsiWhiteSpace @@ -61,14 +53,15 @@ public class AddBracesIntention : JetSelfTargetingIntention(" if (element.getNextSibling()?.getText() == ";") { element.getNextSibling()!!.delete() } - val newElement = bodyNode!!.getPsi()!!.replace(JetPsiFactory.createFunctionBody(element.getProject(), bodyNode.getText())) + val psiFactory = JetPsiFactory(element.getProject()) + val newElement = bodyNode!!.getPsi()!!.replace(psiFactory.createFunctionBody(bodyNode.getText())) //handles the case of the block statement being on a new line if (newElement.getPrevSibling() is PsiWhiteSpace) { - newElement.getPrevSibling()!!.replace(JetPsiFactory.createWhiteSpace(element.getProject())) + newElement.getPrevSibling()!!.replace(psiFactory.createWhiteSpace()) } else { //handles the case of no space between condition and statement - newElement.addBefore(JetPsiFactory.createWhiteSpace(element.getProject()), newElement.getFirstChild()) + newElement.addBefore(psiFactory.createWhiteSpace(), newElement.getFirstChild()) } if (expressionKind == ExpressionKind.DOWHILE) { newElement.getNextSibling()?.delete() diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertAssertToIfWithThrowIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertAssertToIfWithThrowIntention.kt index 14bae9c770b..7c075cca1cb 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertAssertToIfWithThrowIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertAssertToIfWithThrowIntention.kt @@ -61,6 +61,7 @@ public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention "$expression $operatorText $negated" } ) - val newExpression = JetPsiFactory.createExpression(element.getProject(), "$negatedExpression)") + val newExpression = JetPsiFactory(element.getProject()).createExpression("$negatedExpression)") val insertedElement = element.replace(newExpression) val insertedElementParent = insertedElement.getParent() as? JetParenthesizedExpression ?: return diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt index bd725605526..839d20d4b15 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt @@ -19,16 +19,13 @@ package org.jetbrains.jet.plugin.intentions import org.jetbrains.jet.lang.psi.JetParenthesizedExpression import com.intellij.openapi.editor.Editor import org.jetbrains.jet.lang.psi.JetBinaryExpression -import com.intellij.psi.util.PsiUtil import org.jetbrains.jet.lexer.JetTokens import org.jetbrains.jet.lang.psi.JetPrefixExpression import org.jetbrains.jet.lang.psi.JetPsiFactory import com.intellij.psi.impl.source.tree.PsiErrorElementImpl -import org.jetbrains.jet.lang.psi.JetPsiUtil import org.jetbrains.jet.lang.psi.JetExpression import org.jetbrains.jet.lang.psi.JetConstantExpression import org.jetbrains.jet.lang.psi.JetSimpleNameExpression -import java.util.ArrayList import java.util.LinkedList import org.jetbrains.jet.plugin.JetBundle @@ -67,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.createExpression(element.getProject(), negatedExpression) + val newExpression = JetPsiFactory(element.getProject()).createExpression(negatedExpression) element.replace(newExpression) } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToBlockBodyAction.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToBlockBodyAction.kt index 0e797988ac3..c3f7e1bcb49 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToBlockBodyAction.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToBlockBodyAction.kt @@ -21,15 +21,9 @@ import com.intellij.openapi.project.Project import com.intellij.openapi.editor.Editor import com.intellij.psi.PsiElement import com.intellij.psi.util.PsiTreeUtil -import org.jetbrains.jet.lang.psi.JetBlockExpression import org.jetbrains.jet.plugin.JetBundle import org.jetbrains.jet.lang.psi.* -import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache -import org.jetbrains.jet.lang.resolve.BindingContext -import org.jetbrains.jet.lang.types.TypeUtils import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns -import org.jetbrains.jet.lexer.JetTokens -import org.jetbrains.jet.lang.types.JetType public class ConvertToBlockBodyAction : PsiElementBaseIntentionAction() { override fun getFamilyName(): String = JetBundle.message("convert.to.block.body.action.family.name") @@ -50,7 +44,7 @@ public class ConvertToBlockBodyAction : PsiElementBaseIntentionAction() { val oldBodyText = body.getText()!! val newBodyText = if (needReturn) "return ${oldBodyText}" else oldBodyText - return JetPsiFactory.createFunctionBody(project, newBodyText) + return JetPsiFactory(project).createFunctionBody(newBodyText) } if (declaration is JetNamedFunction) { diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToConcatenatedStringIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToConcatenatedStringIntention.kt index 41d21f1908d..dd6a7c0f39c 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToConcatenatedStringIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToConcatenatedStringIntention.kt @@ -32,7 +32,7 @@ public class ConvertToConcatenatedStringIntention : JetSelfTargetingIntention body.getText() ?: throw AssertionError("Body of ForExpression shouldn't be empty: expressionText = ${element.getText()}") }) - element.replace(JetPsiFactory.createExpression(element.getProject(), "${buildReceiverText(element)}.forEach { $bodyText }")) + element.replace(JetPsiFactory(element.getProject()).createExpression("${buildReceiverText(element)}.forEach { $bodyText }")) } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachLoopIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachLoopIntention.kt index bf41094ec4a..89199e4a9cc 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachLoopIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachLoopIntention.kt @@ -113,6 +113,6 @@ public class ConvertToForEachLoopIntention : JetSelfTargetingIntention") @@ -67,7 +68,7 @@ public class InsertExplicitTypeArguments : JetSelfTargetingIntention { val operator = element.getOperationToken()!! @@ -159,10 +158,10 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention JetPsiFactory.wrapInABlock(elseBranch) + element.replace(psiFactory.createIf(replacementCondition, when (elseBranch) { + is JetIfExpression -> psiFactory.wrapInABlock(elseBranch) else -> elseBranch }, if (thenBranch is JetBlockExpression && thenBranch.getStatements().isEmpty()) null else thenBranch)) } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeExplicitInLambdaIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeExplicitInLambdaIntention.kt index 100a3151504..8af3b0e6d6f 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeExplicitInLambdaIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeExplicitInLambdaIntention.kt @@ -63,7 +63,8 @@ public class MakeTypeExplicitInLambdaIntention : JetSelfTargetingIntention "" + descriptor.getName() + ": " + DescriptorRenderer.SOURCE_CODE.renderType(descriptor.getType()) }).makeString(", ", "(", ")") - val newParameterList = JetPsiFactory.createParameterList(element.getProject(), parameterString) + val psiFactory = JetPsiFactory(element.getProject()) + val newParameterList = psiFactory.createParameterList(parameterString) val oldParameterList = functionLiteral.getValueParameterList() if (oldParameterList != null) { oldParameterList.replace(newParameterList) @@ -72,11 +73,11 @@ public class MakeTypeExplicitInLambdaIntention : JetSelfTargetingIntention parameter.getNameIdentifier()!!.getText() }).makeString(", ", "(", ")") - val newParameterList = JetPsiFactory.createParameterList(element.getProject(), parameterString) + val newParameterList = psiFactory.createParameterList(parameterString) oldParameterList.replace(newParameterList) } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/MoveLambdaInsideParenthesesIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/MoveLambdaInsideParenthesesIntention.kt index a84a981b083..68877e99042 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/MoveLambdaInsideParenthesesIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/MoveLambdaInsideParenthesesIntention.kt @@ -49,6 +49,6 @@ public class MoveLambdaInsideParenthesesIntention : JetSelfTargetingIntention return } - val transformed = JetPsiFactory.createExpression(element.getProject(), transformation) + val transformed = JetPsiFactory(element.getProject()).createExpression(transformation) element.replace(transformed) } @@ -177,7 +177,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention("remove.braces", javaClass()) { override fun isApplicableTo(element: JetExpressionImpl): Boolean { @@ -63,7 +54,7 @@ public class RemoveBracesIntention : JetSelfTargetingIntention 42 }") as JetFunctionLiteralExpression + val newExpr = JetPsiFactory(project).createExpression("{ it -> 42 }") as JetFunctionLiteralExpression funcExpr.addRangeAfter(newExpr.getFunctionLiteral().getValueParameterList(), newExpr.getFunctionLiteral().getArrowNode()!!.getPsi(), funcExpr.getOpenBraceNode().getPsi()) diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithDotQualifiedMethodCallIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithDotQualifiedMethodCallIntention.kt index 6f15aaca350..d9e7990d369 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithDotQualifiedMethodCallIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithDotQualifiedMethodCallIntention.kt @@ -17,15 +17,11 @@ package org.jetbrains.jet.plugin.intentions import com.intellij.openapi.editor.Editor -import org.jetbrains.jet.lang.psi.JetSimpleNameExpression import org.jetbrains.jet.lang.psi.JetBinaryExpression import org.jetbrains.jet.lang.psi.JetPsiFactory import org.jetbrains.jet.lang.psi.JetFunctionLiteralExpression import org.jetbrains.jet.lang.psi.JetParenthesizedExpression -import org.jetbrains.jet.lang.types.expressions.OperatorConventions -import com.google.common.collect.ImmutableSet import org.jetbrains.jet.lexer.JetTokens -import org.jetbrains.jet.lexer.JetToken public class ReplaceWithDotQualifiedMethodCallIntention : JetSelfTargetingIntention("replace.with.dot.qualified.method.call.intention", javaClass()) { override fun isApplicableTo(element: JetBinaryExpression): Boolean { @@ -46,7 +42,7 @@ public class ReplaceWithDotQualifiedMethodCallIntention : JetSelfTargetingIntent } ) - val replacement = JetPsiFactory.createExpression(element.getProject(), replacementExpressionStringBuilder.toString()) + val replacement = JetPsiFactory(element.getProject()).createExpression(replacementExpressionStringBuilder.toString()) element.replace(replacement) } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithInfixFunctionCallIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithInfixFunctionCallIntention.kt index dd3c88965fe..14fe5ca6fd8 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithInfixFunctionCallIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithInfixFunctionCallIntention.kt @@ -109,7 +109,7 @@ public open class ReplaceWithInfixFunctionCallIntention : JetSelfTargetingIntent functionLiteralArguments.first().getText() ) - val replacement = JetPsiFactory.createExpression(element.getProject(), "$leftHandText $operatorText ${rightHandTextStringBuilder.toString()}") + val replacement = JetPsiFactory(element.getProject()).createExpression("$leftHandText $operatorText ${rightHandTextStringBuilder.toString()}") parent.replace(replacement) } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithOperatorAssignIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithOperatorAssignIntention.kt index 8870ee01e3f..8c3ac9ac96a 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithOperatorAssignIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithOperatorAssignIntention.kt @@ -111,6 +111,6 @@ public class ReplaceWithOperatorAssignIntention : JetSelfTargetingIntention { val expr = element.getExpression() @@ -81,7 +82,7 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingIntention return element } @@ -114,10 +115,11 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingIntention JetPsiFactory.createExpression( - expression.getProject(), - "${expression.getLeftHandSide().getText() ?: ""} ${invertedOperation.getValue()} ${expression.getTypeRef()?.getText() ?: ""}" - ) - is JetBinaryExpression -> JetPsiFactory.createBinaryExpression( - expression.getProject(), + is JetIsExpression -> { + psiFactory.createExpression( + "${expression.getLeftHandSide().getText() ?: ""} ${invertedOperation.getValue()} ${expression.getTypeRef()?.getText() ?: ""}" + ) + } + is JetBinaryExpression -> psiFactory.createBinaryExpression( expression.getLeft(), invertedOperation.getValue(), expression.getRight() diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java index 9beaf54d100..31a652e20b9 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java +++ b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java @@ -264,8 +264,9 @@ public class SpecifyTypeExplicitlyAction extends PsiElementBaseIntentionAction { } private static void addTypeAnnotationSilently(Project project, JetNamedDeclaration namedDeclaration, PsiElement anchor) { - namedDeclaration.addAfter(JetPsiFactory.createType(project, "Any"), anchor); - namedDeclaration.addAfter(JetPsiFactory.createColon(project), anchor); + JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project); + namedDeclaration.addAfter(psiFactory.createType("Any"), anchor); + namedDeclaration.addAfter(psiFactory.createColon(), anchor); } @Nullable diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/SplitIfIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/SplitIfIntention.kt index dec112ee235..dad1d7b066b 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/SplitIfIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/SplitIfIntention.kt @@ -59,14 +59,19 @@ public class SplitIfIntention : JetSelfTargetingIntention("split. val elseExpression = ifExpression.getElse() val thenExpression = ifExpression.getThen() + val psiFactory = JetPsiFactory(element.getProject()) if (currentElement.getReferencedNameElementType() == JetTokens.ANDAND) { - ifExpression.replace(JetPsiFactory.createIf(element.getProject(), leftExpression, - JetPsiFactory.wrapInABlock(JetPsiFactory.createIf(element.getProject(), rightExpression, thenExpression, - elseExpression)), elseExpression)) + ifExpression.replace( + psiFactory.createIf(leftExpression, psiFactory.wrapInABlock( + psiFactory.createIf(rightExpression, thenExpression, elseExpression) + ), + elseExpression) + ) } else { - ifExpression.replace(JetPsiFactory.createIf(element.getProject(), leftExpression, thenExpression, - JetPsiFactory.createIf(element.getProject(), rightExpression, thenExpression, elseExpression))) + ifExpression.replace(psiFactory.createIf(leftExpression, thenExpression, + psiFactory.createIf(rightExpression, thenExpression, elseExpression)) + ) } } @@ -75,7 +80,7 @@ public class SplitIfIntention : JetSelfTargetingIntention("split. val startOffset = element.getRight()!!.getTextOffset() - condition.getTextOffset() val rightString = condition.getText()!![startOffset, condition.getTextLength()].toString() - return JetPsiFactory.createExpression(element.getProject(), rightString) + return JetPsiFactory(element.getProject()).createExpression(rightString) } fun isCursorOnIfKeyword(element: JetIfExpression, editor: Editor): Boolean { diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/SwapBinaryExpression.kt b/idea/src/org/jetbrains/jet/plugin/intentions/SwapBinaryExpression.kt index 0946126876e..244f27691ea 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/SwapBinaryExpression.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/SwapBinaryExpression.kt @@ -61,11 +61,12 @@ public class SwapBinaryExpression : JetSelfTargetingIntention ifExpression.getCondition()?.let { condition -> val orBranches = condition.splitToOrBranches() @@ -287,7 +285,7 @@ public fun JetIfExpression.transformToWhen() { } } - val whenExpression = builder.toExpression(getProject()).let { whenExpression -> + val whenExpression = builder.toExpression().let { whenExpression -> if (whenExpression.canIntroduceSubject()) whenExpression.introduceSubject() else whenExpression } replace(whenExpression) @@ -306,7 +304,7 @@ public fun JetWhenExpression.transformToIf() { } } - val builder = JetPsiFactory.IfChainBuilder() + val builder = JetPsiFactory(getProject()).IfChainBuilder() for (entry in getEntries()) { val branch = entry.getExpression() @@ -319,7 +317,7 @@ public fun JetWhenExpression.transformToIf() { } } - replace(builder.toExpression(getProject())) + replace(builder.toExpression()) } public fun JetWhenExpression.canMergeWithNext(): Boolean { @@ -367,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.createNewLine(getProject()), expression) + block.addBefore(JetPsiFactory(getProject()).createNewLine(), expression) } block } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt index f7fe9641eba..95616270578 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt @@ -49,7 +49,7 @@ public class DoubleBangToIfThenIntention : JetSelfTargetingIntentioncreateDeclaration(extensionText); PsiElement added = file.addAfter(extension, outermostParent); - file.addAfter(JetPsiFactory.createNewLine(project), outermostParent); - file.addAfter(JetPsiFactory.createNewLine(project), outermostParent); + file.addAfter(psiFactory.createNewLine(), outermostParent); + file.addAfter(psiFactory.createNewLine(), outermostParent); member.delete(); CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(added); @@ -128,7 +129,7 @@ public class ConvertMemberToExtension extends BaseIntentionAction { int caretOffset = added.getTextRange().getStartOffset() + caretAnchor; JetSimpleNameExpression anchor = PsiTreeUtil.findElementOfClassAtOffset(file, caretOffset, JetSimpleNameExpression.class, false); if (anchor != null && CARET_ANCHOR.equals(anchor.getReferencedName())) { - JetExpression throwException = JetPsiFactory.createExpression(project, THROW_UNSUPPORTED_OPERATION_EXCEPTION); + JetExpression throwException = psiFactory.createExpression(THROW_UNSUPPORTED_OPERATION_EXCEPTION); PsiElement replaced = anchor.replace(throwException); TextRange range = replaced.getTextRange(); editor.getCaretModel().moveToOffset(range.getStartOffset()); diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/declarations/DeclarationUtils.java b/idea/src/org/jetbrains/jet/plugin/intentions/declarations/DeclarationUtils.java index e771141ef15..028bf91d3c1 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/declarations/DeclarationUtils.java +++ b/idea/src/org/jetbrains/jet/plugin/intentions/declarations/DeclarationUtils.java @@ -33,6 +33,8 @@ import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import org.jetbrains.jet.plugin.util.JetPsiMatcher; import org.jetbrains.jet.renderer.DescriptorRenderer; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class DeclarationUtils { private DeclarationUtils() { } @@ -103,13 +105,14 @@ public class DeclarationUtils { JetExpression initializer = property.getInitializer(); assertNotNull(initializer); + JetPsiFactory psiFactory = JetPsiFactory(project); //noinspection ConstantConditions, unchecked - JetBinaryExpression newInitializer = JetPsiFactory.createBinaryExpression( - project, JetPsiFactory.createSimpleName(project, property.getName()), "=", initializer + JetBinaryExpression newInitializer = psiFactory.createBinaryExpression( + psiFactory.createSimpleName(property.getName()), "=", initializer ); newInitializer = (JetBinaryExpression) parent.addAfter(newInitializer, property); - parent.addAfter(JetPsiFactory.createNewLine(project), property); + parent.addAfter(psiFactory.createNewLine(), property); //noinspection ConstantConditions JetType inferredType = getPropertyTypeIfNeeded(property); @@ -120,7 +123,7 @@ public class DeclarationUtils { //noinspection ConstantConditions property = (JetProperty) property.replace( - JetPsiFactory.createProperty(project, property.getNameIdentifier().getText(), typeStr, property.isVar()) + psiFactory.createProperty(property.getNameIdentifier().getText(), typeStr, property.isVar()) ); if (inferredType != null) { @@ -133,8 +136,7 @@ public class DeclarationUtils { @NotNull public static JetProperty changePropertyInitializer(@NotNull JetProperty property, @Nullable JetExpression initializer) { //noinspection ConstantConditions - return JetPsiFactory.createProperty( - property.getProject(), + return JetPsiFactory(property).createProperty( property.getNameIdentifier().getText(), JetPsiUtil.getNullableText(property.getTypeRef()), property.isVar(), diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java index addb4928b9f..11c8e1de1bc 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java @@ -31,6 +31,8 @@ import org.jetbrains.jet.lang.psi.JetFunction; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class AddFunctionBodyFix extends JetIntentionAction { public AddFunctionBodyFix(@NotNull JetFunction element) { super(element); @@ -56,11 +58,12 @@ public class AddFunctionBodyFix extends JetIntentionAction { @Override public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { JetFunction newElement = (JetFunction) element.copy(); + JetPsiFactory psiFactory = JetPsiFactory(project); if (!(newElement.getLastChild() instanceof PsiWhiteSpace)) { - newElement.add(JetPsiFactory.createWhiteSpace(project)); + newElement.add(psiFactory.createWhiteSpace()); } if (!newElement.hasBody()) { - newElement.add(JetPsiFactory.createEmptyBody(project)); + newElement.add(psiFactory.createEmptyBody()); } element.replace(newElement); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java index c11b2a8415b..afb7c6676f2 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java @@ -25,7 +25,10 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetModifierList; +import org.jetbrains.jet.lang.psi.JetModifierListOwner; +import org.jetbrains.jet.lang.psi.JetPropertyAccessor; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetModifierKeywordToken; import org.jetbrains.jet.lexer.JetTokens; @@ -34,6 +37,7 @@ import org.jetbrains.jet.plugin.JetBundle; import java.util.HashMap; import java.util.Map; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lexer.JetTokens.*; public class AddModifierFix extends JetIntentionAction { @@ -88,7 +92,7 @@ public class AddModifierFix extends JetIntentionAction { /*package*/ static JetModifierListOwner addModifier(@NotNull PsiElement element, @NotNull JetKeywordToken modifier, @Nullable JetModifierKeywordToken[] modifiersThatCanBeReplaced, @NotNull Project project, boolean toBeginning) { JetModifierListOwner newElement = (JetModifierListOwner) (element.copy()); changeModifier(newElement, newElement.getModifierList(), newElement.getFirstChild(), - modifiersThatCanBeReplaced, project, toBeginning, JetPsiFactory.createModifierList(project, modifier)); + modifiersThatCanBeReplaced, project, toBeginning, JetPsiFactory(project).createModifierList(modifier)); return newElement; } @@ -96,7 +100,7 @@ public class AddModifierFix extends JetIntentionAction { PsiElement element, @Nullable JetModifierList modifierList, @Nullable PsiElement insertAnchor, JetModifierKeywordToken[] modifiersThatCanBeReplaced, Project project, boolean toBeginning, JetModifierList listWithModifier ) { - PsiElement whiteSpace = JetPsiFactory.createWhiteSpace(project); + PsiElement whiteSpace = JetPsiFactory(project).createWhiteSpace(); if (modifierList == null) { if (listWithModifier != null) { if (insertAnchor != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java index b0c986888f6..883e293a3ba 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java @@ -33,7 +33,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetCallElement; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetValueArgument; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; @@ -48,6 +51,8 @@ import java.util.Collections; import java.util.List; import java.util.Set; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class AddNameToArgumentFix extends JetIntentionAction { @NotNull @@ -140,7 +145,7 @@ public class AddNameToArgumentFix extends JetIntentionAction { private static JetValueArgument getParsedArgumentWithName(@NotNull String name, @NotNull JetValueArgument argument) { JetExpression argumentExpression = argument.getArgumentExpression(); assert argumentExpression != null : "Argument should be already parsed."; - return JetPsiFactory.createArgumentWithName(argument.getProject(), name, argumentExpression); + return JetPsiFactory(argument.getProject()).createArgumentWithName(name, argumentExpression); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddSemicolonAfterFunctionCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddSemicolonAfterFunctionCallFix.java index d43e813eaf3..06607cb9893 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddSemicolonAfterFunctionCallFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddSemicolonAfterFunctionCallFix.java @@ -23,9 +23,14 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetCallExpression; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetFunctionLiteralExpression; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class AddSemicolonAfterFunctionCallFix extends JetIntentionAction { JetFunctionLiteralExpression literal; @@ -56,7 +61,7 @@ public class AddSemicolonAfterFunctionCallFix extends JetIntentionAction { private final int argumentCount; @@ -57,7 +59,7 @@ public abstract class AddStarProjectionsFix extends JetIntentionAction { private static final String ELSE_ENTRY_TEXT = "else -> {}"; @@ -63,10 +65,11 @@ public class AddWhenElseBranchFix extends JetIntentionAction PsiElement whenCloseBrace = element.getCloseBrace(); assert (whenCloseBrace != null) : "isAvailable should check if close brace exist"; - JetWhenEntry entry = JetPsiFactory.createWhenEntry(project, ELSE_ENTRY_TEXT); + JetPsiFactory psiFactory = JetPsiFactory(project); + JetWhenEntry entry = psiFactory.createWhenEntry(ELSE_ENTRY_TEXT); PsiElement insertedBranch = element.addBefore(entry, whenCloseBrace); - element.addAfter(JetPsiFactory.createNewLine(project), insertedBranch); + element.addAfter(psiFactory.createNewLine(), insertedBranch); JetWhenEntry insertedWhenEntry = (JetWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch); TextRange textRange = insertedWhenEntry.getTextRange(); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java index 5315f2f9a8b..4ab567b60d2 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java @@ -34,6 +34,8 @@ import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; import org.jetbrains.jet.renderer.DescriptorRenderer; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class CastExpressionFix extends JetIntentionAction { private final JetType type; private final String renderedType; @@ -66,14 +68,15 @@ public class CastExpressionFix extends JetIntentionAction { @Override public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { + JetPsiFactory psiFactory = JetPsiFactory(project); JetBinaryExpressionWithTypeRHS castedExpression = - (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, "(" + element.getText() + ") as " + renderedType); + (JetBinaryExpressionWithTypeRHS) psiFactory.createExpression("(" + element.getText() + ") as " + renderedType); if (JetPsiUtil.areParenthesesUseless((JetParenthesizedExpression) castedExpression.getLeft())) { - castedExpression = (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, element.getText() + " as " + renderedType); + castedExpression = (JetBinaryExpressionWithTypeRHS) psiFactory.createExpression(element.getText() + " as " + renderedType); } JetParenthesizedExpression castedExpressionInParentheses = - (JetParenthesizedExpression) element.replace(JetPsiFactory.createExpression(project, "(" + castedExpression.getText() + ")")); + (JetParenthesizedExpression) element.replace(psiFactory.createExpression("(" + castedExpression.getText() + ")")); if (JetPsiUtil.areParenthesesUseless(castedExpressionInParentheses)) { castedExpressionInParentheses.replace(castedExpression); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java index 46817ebc6b9..04c3eb8a4f4 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java @@ -29,6 +29,8 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.renderer.DescriptorRenderer; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ChangeAccessorTypeFix extends JetIntentionAction { private String renderedType; @@ -65,7 +67,7 @@ public class ChangeAccessorTypeFix extends JetIntentionAction { private final String renderedType; private final JetTypeReference functionLiteralReturnTypeRef; @@ -118,7 +120,7 @@ public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction { private final JetType type; @@ -122,8 +123,9 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction // 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(); } - function.addAfter(JetPsiFactory.createType(project, typeText), elementToPrecedeType); - function.addAfter(JetPsiFactory.createColon(project), elementToPrecedeType); + JetPsiFactory psiFactory = JetPsiFactory(project); + function.addAfter(psiFactory.createType(typeText), elementToPrecedeType); + function.addAfter(psiFactory.createColon(), elementToPrecedeType); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeParameterTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeParameterTypeFix.java index 97d92238015..4a09e00849d 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeParameterTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeParameterTypeFix.java @@ -28,6 +28,8 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.renderer.DescriptorRenderer; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ChangeParameterTypeFix extends JetIntentionAction { private final String renderedType; private final String containingDeclarationName; @@ -65,6 +67,6 @@ public class ChangeParameterTypeFix extends JetIntentionAction { 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.createType(project, renderedType)); + typeReference.replace(JetPsiFactory(project).createType(renderedType)); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToBackingFieldFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToBackingFieldFix.java index 6e1c526d255..8704dba5fe1 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToBackingFieldFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToBackingFieldFix.java @@ -25,6 +25,8 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ChangeToBackingFieldFix extends JetIntentionAction { public ChangeToBackingFieldFix(@NotNull JetSimpleNameExpression element) { super(element); @@ -44,7 +46,7 @@ public class ChangeToBackingFieldFix extends JetIntentionAction { public ChangeToConstructorInvocationFix(@NotNull JetDelegatorToSuperClass element) { @@ -77,7 +79,7 @@ public class ChangeToConstructorInvocationFix extends JetIntentionAction delegationSpecifiers = aClass.getDelegationSpecifiers(); assert delegationSpecifiers.size() == 1; JetDelegationSpecifier specifier = delegationSpecifiers.iterator().next(); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java index e43d9fc3dff..d998096097c 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java @@ -23,9 +23,10 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ChangeToFunctionInvocationFix extends JetIntentionAction { public ChangeToFunctionInvocationFix(@NotNull JetExpression element) { @@ -47,7 +48,7 @@ public class ChangeToFunctionInvocationFix extends JetIntentionAction { public ChangeToPropertyNameFix(@NotNull JetSimpleNameExpression element) { super(element); @@ -53,7 +55,7 @@ public class ChangeToPropertyNameFix extends JetIntentionAction { public ChangeToStarProjectionFix(@NotNull JetTypeElement element) { super(element); @@ -48,7 +53,7 @@ public class ChangeToStarProjectionFix extends JetIntentionAction { private final String renderedType; @@ -55,7 +56,7 @@ public class ChangeTypeFix extends JetIntentionAction { @Override public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { - element.replace(JetPsiFactory.createType(project, renderedType)); + element.replace(JetPsiFactory(project).createType(renderedType)); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java index 2c9cea73427..26b291fefdf 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java @@ -27,7 +27,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetProperty; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; @@ -35,6 +34,8 @@ import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ChangeVariableMutabilityFix implements IntentionAction { private boolean isVar; @@ -87,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.createValOrVarNode(project, isVar ? "val" : "var").getPsi()); + property.getValOrVarNode().getPsi().replace(JetPsiFactory(project).createValOrVarNode(isVar ? "val" : "var").getPsi()); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index 607a52af3ca..fafed03726d 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -83,21 +83,22 @@ public class ChangeVariableTypeFix extends JetIntentionAction "p$i: Any" }.makeString(", ") val returnTypeString = if (isUnit) "" else ": Any" + val psiFactory = JetPsiFactory(project) if (isExtension) { // create as extension function val ownerTypeString = selectedReceiverType.renderedType!! - val func = JetPsiFactory.createFunction(project, "fun $ownerTypeString.$functionName($parametersString)$returnTypeString { }") + val func = psiFactory.createFunction("fun $ownerTypeString.$functionName($parametersString)$returnTypeString { }") containingFile = currentFile containingFileEditor = currentFileEditor return currentFile.add(func) as JetNamedFunction } else { // create as regular function - val func = JetPsiFactory.createFunction(project, "fun $functionName($parametersString)$returnTypeString { }") + val func = psiFactory.createFunction("fun $functionName($parametersString)$returnTypeString { }") containingFile = ownerClass.getContainingJetFile() NavigationUtil.activateFileWithPsiElement(containingFile) @@ -645,8 +642,8 @@ public class CreateFunctionFromUsageFix internal ( var classBody = ownerClass.getBody() if (classBody == null) { - classBody = ownerClass.add(JetPsiFactory.createEmptyClassBody(project)) as JetClassBody - ownerClass.addBefore(JetPsiFactory.createWhiteSpace(project), classBody) + classBody = ownerClass.add(psiFactory.createEmptyClassBody()) as JetClassBody + ownerClass.addBefore(psiFactory.createWhiteSpace(), classBody) } val rBrace = classBody!!.getRBrace() //TODO: Assert rbrace not null? It can be if the class isn't closed. @@ -741,7 +738,7 @@ public class CreateFunctionFromUsageFix internal ( typeRefsToShorten: MutableList, parameterTypeExpressions: List, returnTypeExpression: TypeExpression?) { if (isExtension) { - val receiverTypeRef = JetPsiFactory.createType(func.getProject(), selectedReceiverType.theType.renderLong(typeParameterNameMap)) + val receiverTypeRef = JetPsiFactory(func.getProject()).createType(selectedReceiverType.theType.renderLong(typeParameterNameMap)) replaceWithLongerName(receiverTypeRef, selectedReceiverType.theType) val funcReceiverTypeRef = func.getReceiverTypeRef() @@ -802,7 +799,7 @@ public class CreateFunctionFromUsageFix internal ( throw IncorrectOperationException("Failed to parse file template", e) } - val newBodyExpression = JetPsiFactory.createFunctionBody(func.getProject(), bodyText) + val newBodyExpression = JetPsiFactory(func.getProject()).createFunctionBody(bodyText) func.getBodyExpression()!!.replace(newBodyExpression) } @@ -871,7 +868,7 @@ public class CreateFunctionFromUsageFix internal ( private fun replaceWithLongerName(typeRef: JetTypeReference, theType: JetType) { val project = typeRef.getProject() - val fullyQualifiedReceiverTypeRef = JetPsiFactory.createType(project, theType.renderLong(typeParameterNameMap)) + val fullyQualifiedReceiverTypeRef = JetPsiFactory(project).createType(theType.renderLong(typeParameterNameMap)) typeRef.replace(fullyQualifiedReceiverTypeRef) } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java index 8db90f07d04..28915cbb0d1 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java @@ -34,6 +34,8 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + @SuppressWarnings("IntentionDescriptionNotFoundInspection") public class ExclExclCallFix implements IntentionAction { @@ -83,14 +85,15 @@ public class ExclExclCallFix implements IntentionAction { return; } + JetPsiFactory psiFactory = JetPsiFactory(project); if (!isRemove) { JetExpression modifiedExpression = getExpressionForIntroduceCall(editor, file); - JetExpression exclExclExpression = JetPsiFactory.createExpression(project, modifiedExpression.getText() + "!!"); + JetExpression exclExclExpression = psiFactory.createExpression(modifiedExpression.getText() + "!!"); modifiedExpression.replace(exclExclExpression); } else { JetPostfixExpression postfixExpression = getExclExclPostfixExpression(editor, file); - JetExpression expression = JetPsiFactory.createExpression(project, postfixExpression.getBaseExpression().getText()); + JetExpression expression = psiFactory.createExpression(postfixExpression.getBaseExpression().getText()); postfixExpression.replace(expression); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java index 66ea97590db..66ae864dc56 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java @@ -34,6 +34,8 @@ import org.jetbrains.k2js.analyze.AnalyzerFacadeForJS; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ImportInsertHelper { private ImportInsertHelper() { } @@ -115,20 +117,21 @@ public class ImportInsertHelper { } public static void writeImportToFile(@NotNull ImportPath importPath, @NotNull JetFile file) { + JetPsiFactory psiFactory = JetPsiFactory(file.getProject()); if (file instanceof JetCodeFragment) { - JetImportDirective newDirective = JetPsiFactory.createImportDirective(file.getProject(), importPath); + JetImportDirective newDirective = psiFactory.createImportDirective(importPath); ((JetCodeFragment) file).addImportsFromString(newDirective.getText()); return; } JetImportList importList = file.getImportList(); if (importList != null) { - JetImportDirective newDirective = JetPsiFactory.createImportDirective(file.getProject(), importPath); - importList.add(JetPsiFactory.createNewLine(file.getProject())); + JetImportDirective newDirective = psiFactory.createImportDirective(importPath); + importList.add(psiFactory.createNewLine()); importList.add(newDirective); } else { - JetImportList newDirective = JetPsiFactory.createImportDirectiveWithImportList(file.getProject(), importPath); + JetImportList newDirective = psiFactory.createImportDirectiveWithImportList(importPath); JetPackageDirective packageDirective = file.getPackageDirective(); if (packageDirective == null) { throw new IllegalStateException("Scripts are not supported: " + file.getName()); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/KotlinSuppressIntentionAction.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/KotlinSuppressIntentionAction.kt index 748c4a1bb76..8082fdbad05 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/KotlinSuppressIntentionAction.kt +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/KotlinSuppressIntentionAction.kt @@ -55,9 +55,10 @@ public class KotlinSuppressIntentionAction( private fun suppressAtModifierListOwner(suppressAt: JetModifierListOwner, id: String) { val project = suppressAt.getProject() val modifierList = suppressAt.getModifierList() + val psiFactory = JetPsiFactory(project) if (modifierList == null) { // create a modifier list from scratch - val newModifierList = JetPsiFactory.createModifierList(project, suppressAnnotationText(id)) + val newModifierList = psiFactory.createModifierList(suppressAnnotationText(id)) val replaced = JetPsiUtil.replaceModifierList(suppressAt, newModifierList) val whiteSpace = project.createWhiteSpace(kind) suppressAt.addAfter(whiteSpace, replaced) @@ -66,7 +67,7 @@ public class KotlinSuppressIntentionAction( val entry = findSuppressAnnotation(suppressAt) if (entry == null) { // no [suppress] annotation - val newAnnotation = JetPsiFactory.createAnnotation(project, suppressAnnotationText(id)) + val newAnnotation = psiFactory.createAnnotation(suppressAnnotationText(id)) val addedAnnotation = modifierList.addBefore(newAnnotation, modifierList.getFirstChild()) val whiteSpace = project.createWhiteSpace(kind) modifierList.addAfter(whiteSpace, addedAnnotation) @@ -98,7 +99,7 @@ public class KotlinSuppressIntentionAction( val parentheses = JetPsiPrecedences.getPrecedence(suppressAt) > JetPsiPrecedences.PRECEDENCE_OF_PREFIX_EXPRESSION val placeholderText = "PLACEHOLDER_ID" val inner = if (parentheses) "($placeholderText)" else placeholderText - val annotatedExpression = JetPsiFactory.createExpression(project, suppressAnnotationText(id) + "\n" + inner) + val annotatedExpression = JetPsiFactory(project).createExpression(suppressAnnotationText(id) + "\n" + inner) val copy = suppressAt.copy()!! @@ -115,7 +116,8 @@ public class KotlinSuppressIntentionAction( // add new arguments to an existing entry val args = entry.getValueArgumentList() - val newArgList = JetPsiFactory.createCallArguments(project, "($id)") + val psiFactory = JetPsiFactory(project) + val newArgList = psiFactory.createCallArguments("($id)") if (args == null) { // new argument list entry.addAfter(newArgList, entry.getLastChild()) @@ -126,8 +128,8 @@ public class KotlinSuppressIntentionAction( } else { val rightParen = args.getRightParenthesis() - args.addBefore(JetPsiFactory.createComma(project), rightParen) - args.addBefore(JetPsiFactory.createWhiteSpace(project), rightParen) + args.addBefore(psiFactory.createComma(), rightParen) + args.addBefore(psiFactory.createWhiteSpace(), rightParen) args.addBefore(newArgList.getArguments()[0], rightParen) } } @@ -147,11 +149,10 @@ public class KotlinSuppressIntentionAction( } public class AnnotationHostKind(val kind: String, val name: String, val newLineNeeded: Boolean) -private fun Project.createWhiteSpace(kind: AnnotationHostKind): PsiElement = - if (kind.newLineNeeded) - JetPsiFactory.createNewLine(this) - else - JetPsiFactory.createWhiteSpace(this) +private fun Project.createWhiteSpace(kind: AnnotationHostKind): PsiElement { + val psiFactory = JetPsiFactory(this) + return if (kind.newLineNeeded) psiFactory.createNewLine() else psiFactory.createWhiteSpace() +} private class CaretBox( val expression: E, diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java index 303b6f404c7..eda1eb7462a 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java @@ -45,6 +45,8 @@ import java.util.Collection; import java.util.LinkedHashSet; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class MapPlatformClassToKotlinFix extends JetIntentionAction { private static final String PRIMARY_USAGE = "PrimaryUsage"; private static final String OTHER_USAGE = "OtherUsage"; @@ -125,7 +127,7 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction { public MoveWhenElseBranchFix(@NotNull JetWhenExpression element) { super(element); @@ -68,7 +73,7 @@ public class MoveWhenElseBranchFix extends JetIntentionAction int cursorOffset = editor.getCaretModel().getOffset() - elseEntry.getTextOffset(); PsiElement insertedBranch = element.addAfter(elseEntry, lastEntry); - element.addAfter(JetPsiFactory.createNewLine(project), lastEntry); + element.addAfter(JetPsiFactory(project).createNewLine(), lastEntry); element.deleteChildRange(elseEntry, elseEntry); JetWhenEntry insertedWhenEntry = (JetWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java index 989c065792b..2134496a7c1 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java @@ -27,6 +27,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ReplaceCallFix implements IntentionAction { private final boolean toSafe; @@ -75,8 +77,9 @@ public class ReplaceCallFix implements IntentionAction { JetExpression selector = callExpression.getSelectorExpression(); if (selector != null) { - JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory.createExpression( - project, callExpression.getReceiverExpression().getText() + (toSafe ? "?." : ".") + selector.getText()); + JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory(project).createExpression( + callExpression.getReceiverExpression().getText() + (toSafe ? "?." : ".") + selector.getText() + ); callExpression.replace(newElement); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java index 1accee8fd97..69784760aec 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java @@ -22,9 +22,14 @@ import com.intellij.openapi.project.Project; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetBinaryExpression; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetQualifiedExpression; import org.jetbrains.jet.plugin.JetBundle; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class ReplaceInfixCallFix extends JetIntentionAction { public ReplaceInfixCallFix(@NotNull JetBinaryExpression element) { super(element); @@ -49,7 +54,7 @@ public class ReplaceInfixCallFix extends JetIntentionAction assert left != null && right != null : "Preconditions checked by factory"; String newText = left.getText() + "?." + element.getOperationReference().getText() + "(" + right.getText() + ")"; - JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory.createExpression(project, newText); + JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory(project).createExpression(newText); element.replace(newElement); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java index fba7815309b..3873ffd4e07 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java @@ -44,7 +44,7 @@ public abstract class ReplaceOperationInBinaryExpressionFix> { private final Project project; @@ -46,8 +48,9 @@ public class JetFunctionParameterTableModel extends ParameterTableModelBase(parameterInfo, paramTypeCodeFragment, defaultValueCodeFragment) { @Override public boolean isEllipsisType() { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java index f1441ed4530..ab951ee27d6 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java @@ -26,6 +26,8 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetFunctionCallUsage extends JetUsageInfo { private final PsiElement function; private final boolean isInherited; @@ -44,7 +46,7 @@ public class JetFunctionCallUsage extends JetUsageInfo { JetExpression callee = element.getCalleeExpression(); if (callee instanceof JetSimpleNameExpression) - callee.replace(JetPsiFactory.createSimpleName(getProject(), changeInfo.getNewName())); + callee.replace(JetPsiFactory(getProject()).createSimpleName(changeInfo.getNewName())); } if (arguments != null) { @@ -81,7 +83,7 @@ public class JetFunctionCallUsage extends JetUsageInfo { } parametersBuilder.append(')'); - JetValueArgumentList newArguments = JetPsiFactory.createCallArguments(getProject(), parametersBuilder.toString()); + JetValueArgumentList newArguments = JetPsiFactory(getProject()).createCallArguments(parametersBuilder.toString()); Map argumentMap = getParamIndexToArgumentMap(changeInfo, oldArguments); int argIndex = 0; @@ -146,7 +148,7 @@ public class JetFunctionCallUsage extends JetUsageInfo { if (identifier != null) { String newName = parameterInfo.getInheritedName(isInherited, function, changeInfo.getFunctionDescriptor()); - identifier.replace(JetPsiFactory.createIdentifier(getProject(), newName)); + identifier.replace(JetPsiFactory(getProject()).createIdentifier(newName)); } } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java index ed14ed63c71..ca790405b10 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java @@ -32,6 +32,8 @@ import org.jetbrains.jet.plugin.refactoring.changeSignature.JetChangeInfo; import org.jetbrains.jet.plugin.refactoring.changeSignature.JetParameterInfo; import org.jetbrains.jet.plugin.refactoring.changeSignature.JetValVar; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetFunctionDefinitionUsage extends JetUsageInfo { private final boolean isInherited; @@ -44,6 +46,7 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo { public boolean processUsage(JetChangeInfo changeInfo, PsiElement element) { JetParameterList parameterList; + JetPsiFactory psiFactory = JetPsiFactory(element.getProject()); if (element instanceof JetFunction) { JetFunction function = (JetFunction) element; parameterList = function.getValueParameterList(); @@ -51,8 +54,9 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo { if (changeInfo.isNameChanged()) { PsiElement identifier = function.getNameIdentifier(); - if (identifier != null) - identifier.replace(JetPsiFactory.createIdentifier(element.getProject(), changeInfo.getNewName())); + if (identifier != null) { + identifier.replace(psiFactory.createIdentifier(changeInfo.getNewName())); + } } if (changeInfo.isReturnTypeChanged()) { SpecifyTypeExplicitlyAction.removeTypeAnnotation(function); @@ -68,7 +72,7 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo { if (changeInfo.isParameterSetOrOrderChanged()) { String parametersText = changeInfo.getNewParametersSignature(element, isInherited, 0); - JetParameterList newParameterList = JetPsiFactory.createParameterList(getProject(), parametersText); + JetParameterList newParameterList = psiFactory.createParameterList(parametersText); if (parameterList != null) parameterList = (JetParameterList) parameterList.replace(newParameterList); @@ -99,15 +103,16 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo { private void changeVisibility(JetChangeInfo changeInfo, PsiElement element, JetParameterList parameterList) { JetKeywordToken newVisibilityToken = JetRefactoringUtil.getVisibilityToken(changeInfo.getNewVisibility()); + JetPsiFactory psiFactory = JetPsiFactory(getProject()); if (element instanceof JetFunction) { JetModifierList modifierList = newVisibilityToken == JetTokens.INTERNAL_KEYWORD ? null : - JetPsiFactory.createModifierList(getProject(), newVisibilityToken); + psiFactory.createModifierList(newVisibilityToken); AddModifierFix.changeModifier(element, ((JetFunction) element).getModifierList(), null, ChangeVisibilityModifierFix.VISIBILITY_TOKENS, getProject(), true, modifierList); } else { JetModifierList modifierList = newVisibilityToken == JetTokens.PUBLIC_KEYWORD ? null : - JetPsiFactory.createConstructorModifierList(getProject(), newVisibilityToken); + psiFactory.createConstructorModifierList(newVisibilityToken); AddModifierFix.changeModifier(element, ((JetClass) element).getPrimaryConstructorModifierList(), parameterList, ChangeVisibilityModifierFix.VISIBILITY_TOKENS, getProject(), true, modifierList); } @@ -118,20 +123,23 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo { PsiElement valOrVarNode = valOrVarAstNode != null ? valOrVarAstNode.getPsi() : null; JetValVar valOrVar = parameterInfo.getValOrVar(); + JetPsiFactory psiFactory = JetPsiFactory(getProject()); if (valOrVarNode != null) { - if (valOrVar == JetValVar.None) + if (valOrVar == JetValVar.None) { valOrVarNode.delete(); - else - valOrVarNode.replace(JetPsiFactory.createValOrVarNode(getProject(), valOrVar.toString()).getPsi()); + } + else { + valOrVarNode.replace(psiFactory.createValOrVarNode(valOrVar.toString()).getPsi()); + } } else if (valOrVar != JetValVar.None) { PsiElement firstChild = parameter.getFirstChild(); - parameter.addBefore(JetPsiFactory.createValOrVarNode(getProject(), valOrVar.toString()).getPsi(), firstChild); - parameter.addBefore(JetPsiFactory.createWhiteSpace(getProject()), firstChild); + parameter.addBefore(psiFactory.createValOrVarNode(valOrVar.toString()).getPsi(), firstChild); + parameter.addBefore(psiFactory.createWhiteSpace(), firstChild); } if (parameterInfo.isTypeChanged()) { - JetTypeReference newType = JetPsiFactory.createType(getProject(), parameterInfo.getTypeText()); + JetTypeReference newType = psiFactory.createType(parameterInfo.getTypeText()); JetTypeReference typeReference = parameter.getTypeReference(); if (typeReference != null) @@ -142,7 +150,7 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo { if (identifier != null) { String newName = parameterInfo.getInheritedName(isInherited, element, changeInfo.getFunctionDescriptor()); - identifier.replace(JetPsiFactory.createIdentifier(parameter.getProject(), newName)); + identifier.replace(psiFactory.createIdentifier(newName)); } } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetParameterUsage.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetParameterUsage.java index e6b8f16a55e..71bd8863117 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetParameterUsage.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetParameterUsage.java @@ -18,11 +18,12 @@ package org.jetbrains.jet.plugin.refactoring.changeSignature.usages; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.plugin.refactoring.changeSignature.JetChangeInfo; import org.jetbrains.jet.plugin.refactoring.changeSignature.JetParameterInfo; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class JetParameterUsage extends JetUsageInfo { private final JetParameterInfo parameterInfo; private final PsiElement function; @@ -38,7 +39,7 @@ public class JetParameterUsage extends JetUsageInfo { @Override public boolean processUsage(JetChangeInfo changeInfo, JetSimpleNameExpression element) { String newName = parameterInfo.getInheritedName(isInherited, function, changeInfo.getFunctionDescriptor()); - element.replace(JetPsiFactory.createSimpleName(element.getProject(), newName)); + element.replace(JetPsiFactory(element.getProject()).createSimpleName(newName)); return false; } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionData.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionData.kt index 39ce5127141..00fadc61bb7 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionData.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionData.kt @@ -47,7 +47,6 @@ import org.jetbrains.jet.lang.psi.JetUserType import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor import org.jetbrains.jet.lang.psi.JetPsiFactory -import org.jetbrains.jet.lang.resolve.BindingContextUtils import org.jetbrains.jet.lang.psi.JetFunctionLiteral import org.jetbrains.jet.lang.psi.JetClassInitializer import org.jetbrains.jet.lang.resolve.bindingContextUtil.getResolvedCall @@ -104,7 +103,7 @@ class ExtractionData( val originalStartOffset = originalElements.first?.let { e -> e.getTextRange()!!.getStartOffset() } - private val itFakeDeclaration by Delegates.lazy { JetPsiFactory.createParameter(project, "it", null) } + private val itFakeDeclaration by Delegates.lazy { JetPsiFactory(project).createParameter("it", "Any?") } val refOffsetToDeclaration by Delegates.lazy { fun isExtractableIt(descriptor: DeclarationDescriptor, context: BindingContext): Boolean { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionDescriptor.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionDescriptor.kt index b8a249ffe78..d41364b6d25 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionDescriptor.kt +++ b/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.createSimpleName(e.getProject(), parameter.nameForRef)) + return (thisExpr ?: e).replaced(JetPsiFactory(e.getProject()).createSimpleName(parameter.nameForRef)) } } @@ -82,7 +82,7 @@ class AddPrefixReplacement(override val parameter: Parameter): ParameterReplacem override fun invoke(e: JetElement): JetElement { val selector = (e.getParent() as? JetCallExpression) ?: e val newExpr = selector.replace( - JetPsiFactory.createExpression(e.getProject(), "${parameter.nameForRef}.${selector.getText()}") + JetPsiFactory(e.getProject()).createExpression("${parameter.nameForRef}.${selector.getText()}") ) as JetQualifiedExpression return with(newExpr.getSelectorExpression()!!) { if (this is JetCallExpression) getCalleeExpression()!! else this } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt index c8c371aeef0..fe0d1c973e6 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt @@ -43,7 +43,6 @@ import com.intellij.psi.PsiNamedElement import org.jetbrains.jet.lang.descriptors.impl.LocalVariableDescriptor import org.jetbrains.jet.utils.DFS import org.jetbrains.jet.utils.DFS.* -import org.jetbrains.jet.lang.resolve.BindingContextUtils import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession import org.jetbrains.jet.lang.psi.psiUtil.prependElement import org.jetbrains.jet.lang.psi.psiUtil.appendElement @@ -68,7 +67,6 @@ import org.jetbrains.jet.lang.resolve.OverridingUtil import org.jetbrains.jet.lang.psi.psiUtil.isAncestor import org.jetbrains.jet.plugin.intentions.declarations.DeclarationUtils import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils -import com.intellij.openapi.util.text.StringUtil private val DEFAULT_FUNCTION_NAME = "myFun" private val DEFAULT_RETURN_TYPE = KotlinBuiltIns.getInstance().getUnitType() @@ -801,13 +799,14 @@ fun ExtractionDescriptor.generateFunction( ): JetNamedFunction { val project = extractionData.project + val psiFactory = JetPsiFactory(project) fun createFunction(): JetNamedFunction { return with(extractionData) { if (inTempFile) { createTemporaryFunction("${getFunctionText()}\n") } else { - JetPsiFactory.createFunction(project, getFunctionText()) + psiFactory.createFunction(getFunctionText()) } } } @@ -841,7 +840,7 @@ fun ExtractionDescriptor.generateFunction( val replacingReturn: JetExpression? val expressionsToReplaceWithReturn: List if (controlFlow is JumpBasedControlFlow) { - replacingReturn = JetPsiFactory.createExpression(project, if (controlFlow is ConditionalJump) "return true" else "return") + replacingReturn = psiFactory.createExpression(if (controlFlow is ConditionalJump) "return true" else "return") expressionsToReplaceWithReturn = controlFlow.elementsToReplace.map { jumpElement -> val offsetInBody = jumpElement.getTextRange()!!.getStartOffset() - extractionData.originalStartOffset!! val expr = file.findElementAt(bodyOffset + offsetInBody)?.getParentByType(jumpElement.javaClass) @@ -869,23 +868,23 @@ fun ExtractionDescriptor.generateFunction( for (param in parameters) { param.mirrorVarName?.let { varName -> - body.prependElement(JetPsiFactory.createProperty(project, varName, null, true, param.name)) + body.prependElement(psiFactory.createProperty(varName, null, true, param.name)) } } when (controlFlow) { is ParameterUpdate -> - body.appendElement(JetPsiFactory.createReturn(project, controlFlow.parameter.nameForRef)) + body.appendElement(psiFactory.createReturn(controlFlow.parameter.nameForRef)) is Initializer -> - body.appendElement(JetPsiFactory.createReturn(project, controlFlow.initializedDeclaration.getName()!!)) + body.appendElement(psiFactory.createReturn(controlFlow.initializedDeclaration.getName()!!)) is ConditionalJump -> - body.appendElement(JetPsiFactory.createReturn(project, "false")) + body.appendElement(psiFactory.createReturn("false")) is ExpressionEvaluation -> body.getStatements().last?.let { - val newExpr = it.replaced(JetPsiFactory.createReturn(project, it.getText() ?: throw AssertionError("Return expression shouldn't be empty: code fragment = ${body.getText()}"))).getReturnedExpression()!! + val newExpr = it.replaced(psiFactory.createReturn(it.getText() ?: throw AssertionError("Return expression shouldn't be empty: code fragment = ${body.getText()}"))).getReturnedExpression()!! val counterpartMap = createNameCounterpartMap(it, newExpr) nameByOffset.entrySet().forEach { e -> counterpartMap[e.getValue()]?.let { e.setValue(it) } } } @@ -895,7 +894,7 @@ fun ExtractionDescriptor.generateFunction( fun insertFunction(function: JetNamedFunction): JetNamedFunction { return with(extractionData) { val targetContainer = targetSibling.getParent()!! - val emptyLines = JetPsiFactory.createWhiteSpace(project, "\n\n") + val emptyLines = psiFactory.createWhiteSpace("\n\n") if (insertBefore) { val functionInFile = targetContainer.addBefore(function, targetSibling) as JetNamedFunction targetContainer.addBefore(emptyLines, targetSibling) @@ -924,7 +923,7 @@ fun ExtractionDescriptor.generateFunction( return } - val argumentListExt = JetPsiFactory.createCallArguments(project, "(${wrappedCall.getText()})") + val argumentListExt = psiFactory.createCallArguments("(${wrappedCall.getText()})") val argumentList = enclosingCall.getValueArgumentList() if (argumentList == null) { (anchor.getPrevSibling() as? PsiWhiteSpace)?.let { it.delete() } @@ -933,7 +932,7 @@ fun ExtractionDescriptor.generateFunction( } val newArgText = (argumentList.getArguments() + argumentListExt.getArguments()).map { it.getText() }.joinToString(", ", "(", ")") - argumentList.replace(JetPsiFactory.createCallArguments(project, newArgText)) + argumentList.replace(psiFactory.createCallArguments(newArgText)) anchor.delete() } @@ -956,39 +955,39 @@ fun ExtractionDescriptor.generateFunction( val copiedDeclarations = HashMap() for (decl in controlFlow.declarationsToCopy) { - val declCopy = JetPsiFactory.createDeclaration(project, decl.getText(), javaClass()) + val declCopy = psiFactory.createDeclaration(decl.getText()!!) copiedDeclarations[decl] = anchorParent.addBefore(declCopy, anchor) as JetDeclaration - anchorParent.addBefore(JetPsiFactory.createNewLine(project), anchor) + anchorParent.addBefore(psiFactory.createNewLine(), anchor) } val wrappedCall = when (controlFlow) { is ExpressionEvaluationWithCallSiteReturn -> - JetPsiFactory.createReturn(project, callText) + psiFactory.createReturn(callText) is ParameterUpdate -> - JetPsiFactory.createExpression(project, "${controlFlow.parameter.argumentText} = $callText") + psiFactory.createExpression("${controlFlow.parameter.argumentText} = $callText") is Initializer -> { val newDecl = copiedDeclarations[controlFlow.initializedDeclaration] as JetProperty - newDecl.replace(DeclarationUtils.changePropertyInitializer(newDecl, JetPsiFactory.createExpression(project, callText))) + newDecl.replace(DeclarationUtils.changePropertyInitializer(newDecl, psiFactory.createExpression(callText))) null } is ConditionalJump -> - JetPsiFactory.createExpression(project, "if ($callText) ${controlFlow.elementToInsertAfterCall.getText()}") + psiFactory.createExpression("if ($callText) ${controlFlow.elementToInsertAfterCall.getText()}") is UnconditionalJump -> { anchorParent.addAfter( - JetPsiFactory.createExpression(project, controlFlow.elementToInsertAfterCall.getText()), + psiFactory.createExpression(controlFlow.elementToInsertAfterCall.getText()!!), anchor ) - anchorParent.addAfter(JetPsiFactory.createNewLine(project), anchor) + anchorParent.addAfter(psiFactory.createNewLine(), anchor) - JetPsiFactory.createExpression(project, callText) + psiFactory.createExpression(callText) } else -> - JetPsiFactory.createExpression(project, callText) + psiFactory.createExpression(callText) } insertCall(anchor, wrappedCall) diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java index 64bbeb3554f..cc54c2e841d 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java @@ -69,6 +69,8 @@ import java.util.List; import java.util.Map; import java.util.Set; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class KotlinInlineValHandler extends InlineActionHandler { @Override public boolean isEnabledForLanguage(Language l) { @@ -269,11 +271,12 @@ public class KotlinInlineValHandler extends InlineActionHandler { } } + JetPsiFactory psiFactory = JetPsiFactory(containingFile.getProject()); for (JetFunctionLiteralExpression functionLiteralExpression : functionsToAddParameters) { JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral(); JetParameterList currentParameterList = functionLiteral.getValueParameterList(); - JetParameterList newParameterList = JetPsiFactory.createParameterList(containingFile.getProject(), "(" + parameters + ")"); + JetParameterList newParameterList = psiFactory.createParameterList("(" + parameters + ")"); if (currentParameterList != null) { currentParameterList.replace(newParameterList); } @@ -284,7 +287,7 @@ public class KotlinInlineValHandler extends InlineActionHandler { PsiElement whitespaceToAdd = nextSibling instanceof PsiWhiteSpace && nextSibling.getText().contains("\n") ? nextSibling.copy() : null; - Pair whitespaceAndArrow = JetPsiFactory.createWhitespaceAndArrow(containingFile.getProject()); + Pair whitespaceAndArrow = psiFactory.createWhitespaceAndArrow(); functionLiteral.addRangeAfter(whitespaceAndArrow.getFirst(), whitespaceAndArrow.getSecond(), openBraceElement); functionLiteral.addAfter(newParameterList, openBraceElement); @@ -331,9 +334,9 @@ public class KotlinInlineValHandler extends InlineActionHandler { } } + JetPsiFactory psiFactory = JetPsiFactory(containingFile.getProject()); for (JetCallExpression call : callsToAddArguments) { - call.addAfter(JetPsiFactory.createTypeArguments(containingFile.getProject(), "<" + typeArguments + ">"), - call.getCalleeExpression()); + call.addAfter(psiFactory.createTypeArguments("<" + typeArguments + ">"), call.getCalleeExpression()); ShortenReferences.instance$.process(call.getTypeArgumentList()); } } @@ -380,7 +383,7 @@ public class KotlinInlineValHandler extends InlineActionHandler { !(newExpression instanceof JetSimpleNameExpression)) { JetBlockStringTemplateEntry templateEntry = (JetBlockStringTemplateEntry) referenceElement.getParent().replace( - JetPsiFactory.createBlockStringTemplateEntry(referenceElement.getProject(), newExpression)); + JetPsiFactory(referenceElement.getProject()).createBlockStringTemplateEntry(newExpression)); JetExpression expression = templateEntry.getExpression(); assert expression != null; return expression; diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinChangePropertyActions.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinChangePropertyActions.java index 8afb1bc5951..de55373c024 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinChangePropertyActions.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinChangePropertyActions.java @@ -20,6 +20,7 @@ import com.intellij.lang.ASTNode; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.psi.PsiPackage; public class KotlinChangePropertyActions { private KotlinChangePropertyActions() { @@ -27,11 +28,12 @@ public class KotlinChangePropertyActions { public static void declareValueOrVariable(Project project, boolean isVariable, JetProperty property) { ASTNode node; + JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project); if (isVariable) { - node = JetPsiFactory.createVarNode(project); + node = psiFactory.createVarNode(); } else { - node = JetPsiFactory.createValNode(project); + node = psiFactory.createValNode(); } property.getValOrVarNode().getPsi().replace(node.getPsi()); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java index 79290e9bf24..ece552a8a87 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java @@ -38,7 +38,6 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; -import org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -62,6 +61,7 @@ import org.jetbrains.jet.renderer.DescriptorRenderer; import java.util.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage.getResolvedCall; public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { @@ -272,7 +272,8 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { else { variableText += expression.getText(); } - JetProperty property = JetPsiFactory.createProperty(project, variableText); + JetPsiFactory psiFactory = JetPsiFactory(project); + JetProperty property = psiFactory.createProperty(variableText); PsiElement anchor = calculateAnchor(commonParent, commonContainer, allReplaces); if (anchor == null) return; boolean needBraces = !(commonContainer instanceof JetBlockExpression || @@ -280,21 +281,20 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { commonContainer instanceof JetClassInitializer); if (!needBraces) { property = (JetProperty)commonContainer.addBefore(property, anchor); - commonContainer.addBefore(JetPsiFactory.createNewLine(project), anchor); + commonContainer.addBefore(psiFactory.createNewLine(), anchor); } else { - JetExpression emptyBody = JetPsiFactory.createEmptyBody(project); + JetExpression emptyBody = psiFactory.createEmptyBody(); PsiElement firstChild = emptyBody.getFirstChild(); - emptyBody.addAfter(JetPsiFactory.createNewLine(project), firstChild); + emptyBody.addAfter(psiFactory.createNewLine(), firstChild); if (replaceOccurrence && commonContainer != null) { for (JetExpression replace : allReplaces) { boolean isActualExpression = expression == replace; if (!needParentheses && !(replace.getParent() instanceof JetCallExpression)) { - JetExpression element = - (JetExpression)replace.replace(JetPsiFactory.createExpression(project, suggestedNames[0])); + JetExpression element = (JetExpression) replace.replace(psiFactory.createExpression(suggestedNames[0])); if (isActualExpression) reference.set(element); } else { - JetValueArgumentList argumentList = JetPsiFactory.createCallArguments(project, "(" + suggestedNames[0] + ")"); + JetValueArgumentList argumentList = psiFactory.createCallArguments("(" + suggestedNames[0] + ")"); JetValueArgumentList element = (JetValueArgumentList) replace.replace(argumentList); if (isActualExpression) reference.set(element.getArguments().get(0).getArgumentExpression()); } @@ -334,9 +334,9 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { if (elem != null) { reference.set((JetExpression)elem); } - emptyBody.addAfter(JetPsiFactory.createNewLine(project), firstChild); + emptyBody.addAfter(psiFactory.createNewLine(), firstChild); property = (JetProperty)emptyBody.addAfter(property, firstChild); - emptyBody.addAfter(JetPsiFactory.createNewLine(project), firstChild); + emptyBody.addAfter(psiFactory.createNewLine(), firstChild); actualExpression = reference.get(); diff = actualExpression.getTextRange().getStartOffset() - emptyBody.getTextRange().getStartOffset(); actualExpressionText = actualExpression.getText(); @@ -352,7 +352,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { } else { property = (JetProperty)emptyBody.addAfter(property, firstChild); - emptyBody.addAfter(JetPsiFactory.createNewLine(project), firstChild); + emptyBody.addAfter(psiFactory.createNewLine(), firstChild); emptyBody = (JetExpression)anchor.replace(emptyBody); } for (PsiElement child : emptyBody.getChildren()) { @@ -379,7 +379,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { PsiElement nextnext = next.getNextSibling(); if (nextnext != null && nextnext.getNode().getElementType() == JetTokens.ELSE_KEYWORD) { if (next instanceof PsiWhiteSpace) { - next.replace(JetPsiFactory.createWhiteSpace(project)); + next.replace(psiFactory.createWhiteSpace()); } } } @@ -392,11 +392,11 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { if (!needParentheses && !(replace.getParent() instanceof JetCallExpression)) { JetExpression element = - (JetExpression)replace.replace(JetPsiFactory.createExpression(project, suggestedNames[0])); + (JetExpression)replace.replace(psiFactory.createExpression(suggestedNames[0])); references.add(element); if (isActualExpression) reference.set(element); } else { - JetValueArgumentList argumentList = JetPsiFactory.createCallArguments(project, "(" + suggestedNames[0] + ")"); + JetValueArgumentList argumentList = psiFactory.createCallArguments("(" + suggestedNames[0] + ")"); JetValueArgumentList element = (JetValueArgumentList) replace.replace(argumentList); JetExpression argumentExpression = element.getArguments().get(0).getArgumentExpression(); references.add(argumentExpression); diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt index fad09f9baaf..629dc695107 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt @@ -74,9 +74,10 @@ fun JetSimpleNameExpression.changeQualifiedName(fqName: FqName): JetElement { val project = getProject() val shortName = fqName.shortName().asString() + val psiFactory = JetPsiFactory(project) val fqNameBase = (getParent() as? JetCallExpression)?.let { parent -> val callCopy = parent.copy() as JetCallExpression - callCopy.getCalleeExpression()!!.replace(JetPsiFactory.createSimpleName(project, shortName)).getParent()!!.getText() + callCopy.getCalleeExpression()!!.replace(psiFactory.createSimpleName(shortName)).getParent()!!.getText() } ?: shortName val text = if (!fqName.isOneSegmentFQN()) "${fqName.parent().asString()}.$fqNameBase" else fqNameBase @@ -85,9 +86,9 @@ fun JetSimpleNameExpression.changeQualifiedName(fqName: FqName): JetElement { return when (elementToReplace) { is JetUserType -> { val typeText = "$text${elementToReplace.getTypeArgumentList()?.getText() ?: ""}" - elementToReplace.replace(JetPsiFactory.createType(project, typeText).getTypeElement()!!) + elementToReplace.replace(psiFactory.createType(typeText).getTypeElement()!!) } - else -> elementToReplace.replace(JetPsiFactory.createExpression(project, text)) + else -> elementToReplace.replace(psiFactory.createExpression(text)) } as JetElement } @@ -142,7 +143,7 @@ public fun PsiElement.isInJavaSourceRoot(): Boolean = !JavaProjectRootsUtil.isOutsideJavaSourceRoot(getContainingFile()) public inline fun JetFile.createTempCopy(textTransform: (String) -> String): JetFile { - val tmpFile = JetPsiFactory.createFile(getProject(), getName(), textTransform(getText() ?: "")) + val tmpFile = JetPsiFactory(getProject()).createFile(getName(), textTransform(getText() ?: "")) tmpFile.setOriginalFile(this) tmpFile.skipVisibilityCheck = skipVisibilityCheck return tmpFile diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt index f0dc65384b1..6adea408fcd 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt +++ b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt @@ -39,10 +39,11 @@ public class JetSimpleNameReference( if (newElementName == null) return null; val project = expression.getProject() + val psiFactory = JetPsiFactory(project) val element = when (expression.getReferencedNameElementType()) { - JetTokens.FIELD_IDENTIFIER -> JetPsiFactory.createFieldIdentifier(project, newElementName) - JetTokens.LABEL_IDENTIFIER -> JetPsiFactory.createClassLabel(project, newElementName) - else -> JetPsiFactory.createNameIdentifier(project, newElementName) + JetTokens.FIELD_IDENTIFIER -> psiFactory.createFieldIdentifier(newElementName) + JetTokens.LABEL_IDENTIFIER -> psiFactory.createClassLabel(newElementName) + else -> psiFactory.createNameIdentifier(newElementName) } return expression.getReferencedNameElement().replace(element) diff --git a/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java b/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java index 3b6fb142f2a..f017c272f27 100644 --- a/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java +++ b/idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java @@ -30,6 +30,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; +import com.intellij.psi.PsiPackage; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.usageView.UsageInfo; diff --git a/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt b/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt index ca6421eb3f6..9a574cf9dff 100644 --- a/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt +++ b/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt @@ -68,15 +68,14 @@ private fun JavaCodeInsightTestFixture.configureByCodeFragment(filePath: String) private fun createCodeFragment(filePath: String, contextElement: PsiElement): JetCodeFragment { val fileForFragment = File(filePath + ".fragment") val codeFragmentText = FileUtil.loadFile(fileForFragment, true).trim() + val psiFactory = JetPsiFactory(contextElement.getProject()) if (fileForFragment.readLines().size == 1) { - return JetPsiFactory.createExpressionCodeFragment( - contextElement.getProject(), + return psiFactory.createExpressionCodeFragment( codeFragmentText, KotlinCodeFragmentFactory.getContextElement(contextElement) ) } - return JetPsiFactory.createBlockCodeFragment( - contextElement.getProject(), + return psiFactory.createBlockCodeFragment( codeFragmentText, KotlinCodeFragmentFactory.getContextElement(contextElement) ) diff --git a/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java b/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java index 24a6022ad17..bfec2179ce0 100644 --- a/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java @@ -28,7 +28,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.Visibilities; import org.jetbrains.jet.lang.psi.JetElement; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.KotlinCodeInsightTestCase; @@ -42,6 +41,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.jet.plugin.refactoring.changeSignature.ChangeSignaturePackage.getChangeSignatureDialog; public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { @@ -102,7 +102,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { JetChangeInfo changeInfo = getChangeInfo(); changeInfo.setNewVisibility(Visibilities.PROTECTED); JetParameterInfo newParameter = new JetParameterInfo(-1, "x", KotlinBuiltIns.getInstance().getAnyType(), - null, JetPsiFactory.createValOrVarNode(getProject(), "val")); + null, JetPsiFactory(getProject()).createValOrVarNode("val")); newParameter.setDefaultValueText("12"); changeInfo.addParameter(newParameter); doTest(changeInfo); diff --git a/idea/tests/org/jetbrains/jet/psi/AbstractJetPsiMatcherTest.java b/idea/tests/org/jetbrains/jet/psi/AbstractJetPsiMatcherTest.java index ae0b9fa4645..9b01c6882a0 100644 --- a/idea/tests/org/jetbrains/jet/psi/AbstractJetPsiMatcherTest.java +++ b/idea/tests/org/jetbrains/jet/psi/AbstractJetPsiMatcherTest.java @@ -29,6 +29,8 @@ import org.jetbrains.jet.plugin.util.JetPsiMatcher; import java.io.File; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public abstract class AbstractJetPsiMatcherTest extends JetLiteFixture { public void doTestExpressions(@NotNull String path) throws Exception { String fileText = FileUtil.loadFile(new File(path), true); @@ -36,8 +38,9 @@ public abstract class AbstractJetPsiMatcherTest extends JetLiteFixture { boolean equalityExpected = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// NOT_EQUAL") == null; - JetExpression expr = JetPsiFactory.createExpression(getProject(), fileText); - JetExpression expr2 = JetPsiFactory.createExpression(getProject(), fileText2); + JetPsiFactory psiFactory = JetPsiFactory(getProject()); + JetExpression expr = psiFactory.createExpression(fileText); + JetExpression expr2 = psiFactory.createExpression(fileText2); assertTrue( "JetPsiMatcher.checkElementMatch() should return " + equalityExpected, @@ -51,8 +54,9 @@ public abstract class AbstractJetPsiMatcherTest extends JetLiteFixture { boolean equalityExpected = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// NOT_EQUAL") == null; - JetTypeReference typeRef = JetPsiFactory.createProperty(getProject(), fileText).getTypeRef(); - JetTypeReference typeRef2 = JetPsiFactory.createProperty(getProject(), fileText2).getTypeRef(); + JetPsiFactory psiFactory = JetPsiFactory(getProject()); + JetTypeReference typeRef = psiFactory.createProperty(fileText).getTypeRef(); + JetTypeReference typeRef2 = psiFactory.createProperty(fileText2).getTypeRef(); assertNotNull(typeRef); assertNotNull(typeRef2); diff --git a/j2k/src/org/jetbrains/jet/j2k/AfterConversionPass.kt b/j2k/src/org/jetbrains/jet/j2k/AfterConversionPass.kt index ee74092ecd0..bba3de3f81a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/AfterConversionPass.kt +++ b/j2k/src/org/jetbrains/jet/j2k/AfterConversionPass.kt @@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.psi.JetProperty class AfterConversionPass(val project: Project) { public fun run(kotlinCode: String): String { - val kotlinFile = JetPsiFactory.createFile(project, kotlinCode) + val kotlinFile = JetPsiFactory(project).createFile(kotlinCode) val analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( project, listOf(kotlinFile), @@ -70,7 +70,7 @@ class AfterConversionPass(val project: Project) { Errors.VAL_REASSIGNMENT -> { () -> val property = (psiElement as? JetSimpleNameExpression)?.getReference()?.resolve() as? JetProperty if (property != null && !property.isVar()) { - property.getValOrVarNode().getPsi()!!.replace(JetPsiFactory.createVarNode(project).getPsi()!!) + property.getValOrVarNode().getPsi()!!.replace(JetPsiFactory(project).createVarNode().getPsi()!!) } } diff --git a/js/js.tests/test/org/jetbrains/k2js/test/utils/TranslationUtils.java b/js/js.tests/test/org/jetbrains/k2js/test/utils/TranslationUtils.java index f9492eccf37..5720eb481eb 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/utils/TranslationUtils.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/utils/TranslationUtils.java @@ -27,7 +27,6 @@ import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.k2js.analyze.AnalyzerFacadeForJS; import org.jetbrains.k2js.config.Config; import org.jetbrains.k2js.config.EcmaVersion; @@ -40,6 +39,7 @@ import java.io.IOException; import java.lang.ref.SoftReference; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.k2js.facade.K2JSTranslator.translateWithMainCallParameters; //TODO: use method object @@ -147,7 +147,7 @@ public final class TranslationUtils { try { String path = root == null ? libFileName : (root + libFileName); String text = FileUtil.loadFile(new File(path), true); - JetFile jetFile = JetPsiFactory.createFile(project, path, text); + JetFile jetFile = JetPsiFactory(project).createFile(path, text); libFiles.add(jetFile); } catch (IOException e) { diff --git a/js/js.translator/src/org/jetbrains/k2js/config/LibrarySourcesConfig.java b/js/js.translator/src/org/jetbrains/k2js/config/LibrarySourcesConfig.java index bfff305b0e4..fbae2b8a091 100644 --- a/js/js.translator/src/org/jetbrains/k2js/config/LibrarySourcesConfig.java +++ b/js/js.translator/src/org/jetbrains/k2js/config/LibrarySourcesConfig.java @@ -27,7 +27,6 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import java.io.IOException; import java.io.InputStream; @@ -38,6 +37,8 @@ import java.util.List; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + public class LibrarySourcesConfig extends Config { @NotNull public static final Key EXTERNAL_MODULE_NAME = Key.create("externalModule"); @@ -122,7 +123,7 @@ public class LibrarySourcesConfig extends Config { if (!entry.isDirectory() && entry.getName().endsWith(".kt")) { InputStream stream = file.getInputStream(entry); String text = StringUtil.convertLineSeparators(FileUtil.loadTextAndClose(stream)); - JetFile jetFile = JetPsiFactory.createFile(getProject(), entry.getName(), text); + JetFile jetFile = JetPsiFactory(getProject()).createFile(entry.getName(), text); jetFile.putUserData(EXTERNAL_MODULE_NAME, UNKNOWN_EXTERNAL_MODULE_NAME); result.add(jetFile); } diff --git a/js/js.translator/src/org/jetbrains/k2js/config/MetaInfServices.java b/js/js.translator/src/org/jetbrains/k2js/config/MetaInfServices.java index 3d6dedcfcba..f0fd334fc27 100644 --- a/js/js.translator/src/org/jetbrains/k2js/config/MetaInfServices.java +++ b/js/js.translator/src/org/jetbrains/k2js/config/MetaInfServices.java @@ -21,7 +21,6 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import java.io.BufferedReader; import java.io.IOException; @@ -30,6 +29,8 @@ import java.io.InputStreamReader; import java.net.URL; import java.util.*; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; + /** * A helper class to discover a META-INF/services file on the classpath and load the files referenced inside it */ @@ -75,7 +76,7 @@ public final class MetaInfServices { InputStream stream = loadClasspathResource(line); if (stream != null) { String text = StringUtil.convertLineSeparators(FileUtil.loadTextAndClose(stream)); - libFiles.add(JetPsiFactory.createFile(project, line, text)); + libFiles.add(JetPsiFactory(project).createFile(line, text)); } } } diff --git a/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java b/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java index 4dec2de4c8e..4196f2e7039 100644 --- a/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java @@ -31,7 +31,6 @@ import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.SimpleOutputFile; import org.jetbrains.jet.SimpleOutputFileCollection; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.utils.fileUtils.FileUtilsPackage; import org.jetbrains.js.compiler.JsSourceGenerationVisitor; @@ -47,6 +46,7 @@ import java.io.IOException; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.k2js.facade.FacadeUtils.parseString; /** @@ -108,7 +108,7 @@ public final class K2JSTranslator { @SuppressWarnings("UnusedDeclaration") @NotNull public String translateStringWithCallToMain(@NotNull String programText, @NotNull String argumentsString) throws TranslationException { - JetFile file = JetPsiFactory.createFile(getProject(), "test", programText); + JetFile file = JetPsiFactory(getProject()).createFile("test", programText); String programCode = generateProgramCode(file, MainCallParameters.mainWithArguments(parseString(argumentsString))) + "\n"; return FLUSH_SYSTEM_OUT + programCode + GET_SYSTEM_OUT; }