azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Translate intention classes to Kotlin and apply refactoring

Browse Source
This commit is contained in:
Alexey Sedunov
2013-11-18 13:37:56 +04:00
parent 6b971fa50c
commit 72f4ae3a13
54 changed files with 527 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files
annotations/com/intellij/codeInsight/intention/annotations.xml
+14
View File
@@ -0,0 +1,14 @@
<root>
<item
name='com.intellij.codeInsight.intention.IntentionAction boolean isAvailable(com.intellij.openapi.project.Project, com.intellij.openapi.editor.Editor, com.intellij.psi.PsiFile)'>
<annotation name='jet.runtime.typeinfo.KotlinSignature'>
<val name="value" val="&quot;fun isAvailable(project: Project, editor: Editor, file: PsiFile): Boolean&quot;"/>
</annotation>
</item>
<item
name='com.intellij.codeInsight.intention.IntentionAction void invoke(com.intellij.openapi.project.Project, com.intellij.openapi.editor.Editor, com.intellij.psi.PsiFile)'>
<annotation name='jet.runtime.typeinfo.KotlinSignature'>
<val name="value" val="&quot;fun invoke(project: Project, editor: Editor, file: PsiFile): Unit&quot;"/>
</annotation>
</item>
</root>
idea/resources/intentionDescriptions/FoldIfToAssignmentIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
res = if (ok) {
"ok"
} else {
"failed"
}
idea/resources/intentionDescriptions/FoldIfToAssignmentIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
if (ok) {
res = "ok"
} else {
res = "failed"
}
idea/resources/intentionDescriptions/FoldBranchedExpressionIntentionFoldIfToAssignmentIntention/description.html → idea/resources/intentionDescriptions/FoldIfToAssignmentIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts 'if' expression where each branch is terminated with assignment into a single assignment with 'if' expression as a right-hand side
</body>
</html>
</html>
idea/resources/intentionDescriptions/FoldIfToReturnAsymmetricallyIntention/after.kt.template
+3
View File
@@ -0,0 +1,3 @@
return if (ok) {
"ok"
} else "failed"
idea/resources/intentionDescriptions/FoldIfToReturnAsymmetricallyIntention/before.kt.template
+4
View File
@@ -0,0 +1,4 @@
if (ok) {
return "ok"
}
return "failed"
idea/resources/intentionDescriptions/FoldBranchedExpressionIntentionFoldIfToReturnAsymmetricallyIntention/description.html → idea/resources/intentionDescriptions/FoldIfToReturnAsymmetricallyIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts single-branch 'if' expression immediately followed by 'return' into a single 'return' with 'if' expression as an argument
</body>
</html>
</html>
idea/resources/intentionDescriptions/FoldIfToReturnIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
return if (ok) {
"ok"
} else {
"failed"
}
idea/resources/intentionDescriptions/FoldIfToReturnIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
if (ok) {
return "ok"
} else {
return "failed"
}
idea/resources/intentionDescriptions/FoldBranchedExpressionIntentionFoldIfToReturnIntention/description.html → idea/resources/intentionDescriptions/FoldIfToReturnIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts 'if' expression where each branch is terminated with 'return' into a single 'return' with 'if' expression as a right-hand side
</body>
</html>
</html>
idea/resources/intentionDescriptions/FoldWhenToAssignmentIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
res = when (n) {
1 -> "one"
2 -> "two"
else -> "many"
}
idea/resources/intentionDescriptions/FoldWhenToAssignmentIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
when (n) {
1 -> res = "one"
2 -> res = "two"
else -> res = "many"
}
idea/resources/intentionDescriptions/FoldBranchedExpressionIntentionFoldWhenToAssignmentIntention/description.html → idea/resources/intentionDescriptions/FoldWhenToAssignmentIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts 'when' expression where each branch is terminated with assignment into a single assignment with 'when' expression as right-hand side
</body>
</html>
</html>
idea/resources/intentionDescriptions/FoldWhenToReturnIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
return when (n) {
1 -> "one"
2 -> "two"
else -> "many"
}
idea/resources/intentionDescriptions/FoldWhenToReturnIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
when (n) {
1 -> return "one"
2 -> return "two"
else -> return "many"
}
idea/resources/intentionDescriptions/FoldBranchedExpressionIntentionFoldWhenToReturnIntention/description.html → idea/resources/intentionDescriptions/FoldWhenToReturnIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts 'when' expression where each branch is terminated with 'return' into a single 'return' with 'when' expression as a right-hand side
</body>
</html>
</html>
idea/resources/intentionDescriptions/UnfoldAssignmentToIfIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
if (ok) {
res = "ok"
} else {
res = "failed"
}
idea/resources/intentionDescriptions/UnfoldAssignmentToIfIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
res = if (ok) {
"ok"
} else {
"failed"
}
idea/resources/intentionDescriptions/UnfoldBranchedExpressionIntentionUnfoldAssignmentToIfIntention/description.html → idea/resources/intentionDescriptions/UnfoldAssignmentToIfIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts assignment with 'if' right-hand side to 'if' expression where each branch is terminated with assignment
</body>
</html>
</html>
idea/resources/intentionDescriptions/UnfoldAssignmentToWhenIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
when (n) {
1 -> res = "one"
2 -> res = "two"
else -> res = "many"
}
idea/resources/intentionDescriptions/UnfoldAssignmentToWhenIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
res = when (n) {
1 -> "one"
2 -> "two"
else -> "many"
}
idea/resources/intentionDescriptions/UnfoldBranchedExpressionIntentionUnfoldAssignmentToWhenIntention/description.html → idea/resources/intentionDescriptions/UnfoldAssignmentToWhenIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts assignment with 'when' right-hand side to 'when' expression where each branch is terminated with assignment
</body>
</html>
</html>
idea/resources/intentionDescriptions/UnfoldPropertyToIfIntention/after.kt.template
+6
View File
@@ -0,0 +1,6 @@
val res: String
if (ok) {
res = "ok"
} else {
res = "failed"
}
idea/resources/intentionDescriptions/UnfoldPropertyToIfIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
val res = if (ok) {
"ok"
} else {
"failed"
}
idea/resources/intentionDescriptions/UnfoldBranchedExpressionIntentionUnfoldPropertyToIfIntention/description.html → idea/resources/intentionDescriptions/UnfoldPropertyToIfIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts property with 'if' initializer to uninitialized property followed by 'if' expression where each branch is terminated with assignment
</body>
</html>
</html>
idea/resources/intentionDescriptions/UnfoldPropertyToWhenIntention/after.kt.template
+6
View File
@@ -0,0 +1,6 @@
val res: String
when (n) {
1 -> res = "one"
2 -> res = "two"
else -> res = "many"
}
idea/resources/intentionDescriptions/UnfoldPropertyToWhenIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
val res = when (n) {
1 -> "one"
2 -> "two"
else -> "many"
}
idea/resources/intentionDescriptions/UnfoldBranchedExpressionIntentionUnfoldPropertyToWhenIntention/description.html → idea/resources/intentionDescriptions/UnfoldPropertyToWhenIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts property with 'when' initializer to uninitialized property followed by 'when' expression where each branch is terminated with assignment
</body>
</html>
</html>
idea/resources/intentionDescriptions/UnfoldReturnToIfIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
if (ok) {
return "ok"
} else {
return "failed"
}
idea/resources/intentionDescriptions/UnfoldReturnToIfIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
return if (ok) {
"ok"
} else {
"failed"
}
idea/resources/intentionDescriptions/UnfoldBranchedExpressionIntentionUnfoldReturnToIfIntention/description.html → idea/resources/intentionDescriptions/UnfoldReturnToIfIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts 'return' with 'if' expression as a result to 'if' expression where each branch is terminated with 'return'
</body>
</html>
</html>
idea/resources/intentionDescriptions/UnfoldReturnToWhenIntention/after.kt.template
+5
View File
@@ -0,0 +1,5 @@
when (n) {
1 -> return "one"
2 -> return "two"
else -> return "many"
}
idea/resources/intentionDescriptions/UnfoldReturnToWhenIntention/before.kt.template
+5
View File
@@ -0,0 +1,5 @@
return when (n) {
1 -> "one"
2 -> "two"
else -> "many"
}
idea/resources/intentionDescriptions/UnfoldBranchedExpressionIntentionUnfoldReturnToWhenIntention/description.html → idea/resources/intentionDescriptions/UnfoldReturnToWhenIntention/description.html
+1 -1
View File
@@ -2,4 +2,4 @@
<body>
This intention converts 'return' with 'when' expression as a result to 'when' expression where each branch is terminated with 'return'
</body>
</html>
</html>
idea/src/META-INF/plugin.xml
+11 -11
View File
@@ -365,57 +365,57 @@
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldBranchedExpressionIntention$FoldIfToAssignmentIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldIfToAssignmentIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldBranchedExpressionIntention$FoldIfToReturnAsymmetricallyIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldIfToReturnAsymmetricallyIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldBranchedExpressionIntention$FoldIfToReturnIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldIfToReturnIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldBranchedExpressionIntention$FoldWhenToAssignmentIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldWhenToAssignmentIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldBranchedExpressionIntention$FoldWhenToReturnIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.FoldWhenToReturnIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldBranchedExpressionIntention$UnfoldAssignmentToIfIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldAssignmentToIfIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldBranchedExpressionIntention$UnfoldPropertyToIfIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldPropertyToIfIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldBranchedExpressionIntention$UnfoldAssignmentToWhenIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldAssignmentToWhenIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldBranchedExpressionIntention$UnfoldPropertyToWhenIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldPropertyToWhenIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldBranchedExpressionIntention$UnfoldReturnToIfIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldReturnToIfIntention</className>
<category>Kotlin</category>
</intentionAction>
<intentionAction>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldBranchedExpressionIntention$UnfoldReturnToWhenIntention</className>
<className>org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions.UnfoldReturnToWhenIntention</className>
<category>Kotlin</category>
</intentionAction>
idea/src/org/jetbrains/jet/plugin/intentions/AbstractCodeTransformationIntention.java
-68
View File
@@ -1,68 +0,0 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions;
import com.intellij.codeInsight.intention.impl.BaseIntentionAction;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.util.IncorrectOperationException;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetElement;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
import org.jetbrains.jet.plugin.JetBundle;
public abstract class AbstractCodeTransformationIntention extends BaseIntentionAction {
private final Transformer transformer;
private final Function1<PsiElement, Boolean> isApplicable;
protected AbstractCodeTransformationIntention(@NotNull Transformer transformer, @NotNull Function1<PsiElement, Boolean> isApplicable) {
this.transformer = transformer;
this.isApplicable = isApplicable;
setText(JetBundle.message(transformer.getKey()));
}
@Nullable
private PsiElement getTarget(@NotNull Editor editor, @NotNull PsiFile file) {
PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
return PsiUtilPackage.getParentByTypeAndPredicate(element, JetElement.class, false, isApplicable);
}
@NotNull
@Override
public String getFamilyName() {
return JetBundle.message(transformer.getKey() + ".family");
}
@Override
public boolean isAvailable(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) {
return getTarget(editor, file) != null;
}
@Override
public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) throws IncorrectOperationException {
PsiElement target = getTarget(editor, file);
assert target != null : "Intention is not applicable";
transformer.transform(target, editor, (JetFile) file);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/JetSelfTargetingIntention.kt
+59
View File
@@ -0,0 +1,59 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions
import com.intellij.codeInsight.intention.impl.BaseIntentionAction
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.project.Project
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiFile
import com.intellij.util.IncorrectOperationException
import jet.Function1
import org.jetbrains.annotations.Nullable
import org.jetbrains.jet.lang.psi.JetElement
import org.jetbrains.jet.lang.psi.JetFile
import org.jetbrains.jet.plugin.JetBundle
import org.jetbrains.jet.lang.psi.psiUtil.getParentByTypeAndPredicate
public abstract class JetSelfTargetingIntention<T: JetElement>(val key: String, val elementType: Class<T>) : BaseIntentionAction() {
{
setText(JetBundle.message(key))
}
protected abstract fun isApplicableTo(element: T): Boolean
protected abstract fun applyTo(element: T, editor: Editor)
private fun getTarget(editor: Editor, file: PsiFile): T? {
val offset = editor.getCaretModel().getOffset()
return file.findElementAt(offset)?.getParentByTypeAndPredicate(elementType) { element -> isApplicableTo(element) }
}
public override fun getFamilyName(): String {
return JetBundle.message(key + ".family")
}
public override fun isAvailable(project: Project, editor: Editor, file: PsiFile): Boolean {
return getTarget(editor, file) != null
}
public override fun invoke(project: Project, editor: Editor, file: PsiFile): Unit {
val target = getTarget(editor, file)
assert(target != null, "Intention is not applicable")
applyTo(target!!, editor)
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/EliminateWhenSubjectIntention.java
-38
View File
@@ -1,38 +0,0 @@
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetWhenExpression;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.WhenUtils;
import org.jetbrains.jet.plugin.intentions.Transformer;
public class EliminateWhenSubjectIntention extends AbstractCodeTransformationIntention {
private static final Transformer TRANSFORMER = new Transformer() {
@NotNull
@Override
public String getKey() {
return "eliminate.when.subject";
}
@Override
public void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file) {
WhenUtils.eliminateWhenSubject((JetWhenExpression) element);
}
};
private static final Function1<PsiElement, Boolean> IS_APPLICABLE = new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return input instanceof JetWhenExpression && WhenUtils.checkEliminateWhenSubject((JetWhenExpression) input);
}
};
public EliminateWhenSubjectIntention() {
super(TRANSFORMER, IS_APPLICABLE);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/EliminateWhenSubjectIntention.kt
+30
View File
@@ -0,0 +1,30 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.branchedTransformations.WhenUtils
import org.jetbrains.jet.lang.psi.JetWhenExpression
import com.intellij.openapi.editor.Editor
public class EliminateWhenSubjectIntention : JetSelfTargetingIntention<JetWhenExpression>("eliminate.when.subject", javaClass()) {
override fun isApplicableTo(element: JetWhenExpression): Boolean = WhenUtils.checkEliminateWhenSubject(element)
override fun applyTo(element: JetWhenExpression, editor: Editor) {
WhenUtils.eliminateWhenSubject(element)
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/FlattenWhenIntention.java
-38
View File
@@ -1,38 +0,0 @@
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetWhenExpression;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.WhenUtils;
import org.jetbrains.jet.plugin.intentions.Transformer;
public class FlattenWhenIntention extends AbstractCodeTransformationIntention {
private static final Transformer TRANSFORMER = new Transformer() {
@NotNull
@Override
public String getKey() {
return "flatten.when";
}
@Override
public void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file) {
WhenUtils.flattenWhen((JetWhenExpression) element);
}
};
private static final Function1<PsiElement, Boolean> IS_APPLICABLE = new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return input instanceof JetWhenExpression && WhenUtils.checkFlattenWhen((JetWhenExpression) input);
}
};
public FlattenWhenIntention() {
super(TRANSFORMER, IS_APPLICABLE);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/FlattenWhenIntention.kt
+30
View File
@@ -0,0 +1,30 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.branchedTransformations.WhenUtils
import org.jetbrains.jet.lang.psi.JetWhenExpression
import com.intellij.openapi.editor.Editor
public class FlattenWhenIntention : JetSelfTargetingIntention<JetWhenExpression>("flatten.when", javaClass()) {
override fun isApplicableTo(element: JetWhenExpression): Boolean = WhenUtils.checkFlattenWhen(element)
override fun applyTo(element: JetWhenExpression, editor: Editor) {
WhenUtils.flattenWhen(element)
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/FoldBranchedExpressionIntention.java
-70
View File
@@ -1,70 +0,0 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.BranchedFoldingUtils;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.FoldableKind;
public abstract class FoldBranchedExpressionIntention extends AbstractCodeTransformationIntention {
protected FoldBranchedExpressionIntention(@NotNull final FoldableKind foldableKind) {
super(
foldableKind,
new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return (input instanceof JetExpression) && BranchedFoldingUtils.getFoldableExpressionKind((JetExpression) input) == foldableKind;
}
}
);
}
public static class FoldIfToAssignmentIntention extends FoldBranchedExpressionIntention {
public FoldIfToAssignmentIntention() {
super(FoldableKind.IF_TO_ASSIGNMENT);
}
}
public static class FoldIfToReturnAsymmetricallyIntention extends FoldBranchedExpressionIntention {
public FoldIfToReturnAsymmetricallyIntention() {
super(FoldableKind.IF_TO_RETURN_ASYMMETRICALLY);
}
}
public static class FoldIfToReturnIntention extends FoldBranchedExpressionIntention {
public FoldIfToReturnIntention() {
super(FoldableKind.IF_TO_RETURN);
}
}
public static class FoldWhenToAssignmentIntention extends FoldBranchedExpressionIntention {
public FoldWhenToAssignmentIntention() {
super(FoldableKind.WHEN_TO_ASSIGNMENT);
}
}
public static class FoldWhenToReturnIntention extends FoldBranchedExpressionIntention {
public FoldWhenToReturnIntention() {
super(FoldableKind.WHEN_TO_RETURN);
}
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/FoldBranchedExpressionIntention.kt
+57
View File
@@ -0,0 +1,57 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import com.intellij.psi.PsiElement
import jet.Function1
import org.jetbrains.annotations.Nullable
import org.jetbrains.jet.lang.psi.JetExpression
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.branchedTransformations.BranchedFoldingUtils
import org.jetbrains.jet.plugin.intentions.branchedTransformations.FoldableKind
import org.jetbrains.jet.lang.psi.JetElement
import com.intellij.openapi.editor.Editor
import org.jetbrains.jet.lang.psi.JetFile
import org.jetbrains.jet.lang.psi.JetIfExpression
import org.jetbrains.jet.lang.psi.JetWhenExpression
public open class FoldBranchedExpressionIntention<T: JetExpression>(
val kind: FoldableKind, elementType: Class<T>
) : JetSelfTargetingIntention<T>(kind.getKey(), elementType) {
override fun isApplicableTo(element: T): Boolean = BranchedFoldingUtils.getFoldableExpressionKind(element) == kind
override fun applyTo(element: T, editor: Editor) {
val file = element.getContainingFile()
if (file is JetFile) {
kind.transform(element, editor, file)
}
}
}
public class FoldIfToAssignmentIntention : FoldBranchedExpressionIntention<JetIfExpression>(FoldableKind.IF_TO_ASSIGNMENT, javaClass())
public class FoldIfToReturnAsymmetricallyIntention : FoldBranchedExpressionIntention<JetIfExpression>(
FoldableKind.IF_TO_RETURN_ASYMMETRICALLY, javaClass()
)
public class FoldIfToReturnIntention : FoldBranchedExpressionIntention<JetIfExpression>(FoldableKind.IF_TO_RETURN, javaClass())
public class FoldWhenToAssignmentIntention : FoldBranchedExpressionIntention<JetWhenExpression>(
FoldableKind.WHEN_TO_ASSIGNMENT, javaClass()
)
public class FoldWhenToReturnIntention : FoldBranchedExpressionIntention<JetWhenExpression>(FoldableKind.WHEN_TO_RETURN, javaClass())
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IfToWhenIntention.java
-38
View File
@@ -1,38 +0,0 @@
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetIfExpression;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.IfWhenUtils;
import org.jetbrains.jet.plugin.intentions.Transformer;
public class IfToWhenIntention extends AbstractCodeTransformationIntention {
private static final Transformer TRANSFORMER = new Transformer() {
@NotNull
@Override
public String getKey() {
return "if.to.when";
}
@Override
public void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file) {
IfWhenUtils.transformIfToWhen((JetIfExpression) element);
}
};
private static final Function1<PsiElement, Boolean> IS_APPLICABLE = new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return (input instanceof JetIfExpression) && IfWhenUtils.checkIfToWhen((JetIfExpression) input);
}
};
public IfToWhenIntention() {
super(TRANSFORMER, IS_APPLICABLE);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IfToWhenIntention.kt
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.branchedTransformations.IfWhenUtils
import org.jetbrains.jet.lang.psi.JetWhenExpression
import org.jetbrains.jet.lang.psi.JetIfExpression
import com.intellij.openapi.editor.Editor
public class IfToWhenIntention : JetSelfTargetingIntention<JetIfExpression>("if.to.when", javaClass()) {
override fun isApplicableTo(element: JetIfExpression): Boolean = IfWhenUtils.checkIfToWhen(element)
override fun applyTo(element: JetIfExpression, editor: Editor) {
IfWhenUtils.transformIfToWhen(element)
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IntroduceWhenSubjectIntention.java
-38
View File
@@ -1,38 +0,0 @@
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetWhenExpression;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.WhenUtils;
import org.jetbrains.jet.plugin.intentions.Transformer;
public class IntroduceWhenSubjectIntention extends AbstractCodeTransformationIntention {
private static final Transformer TRANSFORMER = new Transformer() {
@NotNull
@Override
public String getKey() {
return "introduce.when.subject";
}
@Override
public void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file) {
WhenUtils.introduceWhenSubject((JetWhenExpression) element);
}
};
private static final Function1<PsiElement, Boolean> IS_APPLICABLE = new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return input instanceof JetWhenExpression && WhenUtils.checkIntroduceWhenSubject((JetWhenExpression) input);
}
};
public IntroduceWhenSubjectIntention() {
super(TRANSFORMER, IS_APPLICABLE);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IntroduceWhenSubjectIntention.kt
+30
View File
@@ -0,0 +1,30 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.branchedTransformations.WhenUtils
import org.jetbrains.jet.lang.psi.JetWhenExpression
import com.intellij.openapi.editor.Editor
public class IntroduceWhenSubjectIntention : JetSelfTargetingIntention<JetWhenExpression>("introduce.when.subject", javaClass()) {
override fun isApplicableTo(element: JetWhenExpression): Boolean = WhenUtils.checkIntroduceWhenSubject(element)
override fun applyTo(element: JetWhenExpression, editor: Editor) {
WhenUtils.introduceWhenSubject(element)
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/UnfoldBranchedExpressionIntention.java
-75
View File
@@ -1,75 +0,0 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.*;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
public abstract class UnfoldBranchedExpressionIntention extends AbstractCodeTransformationIntention {
protected UnfoldBranchedExpressionIntention(@NotNull final UnfoldableKind unfoldableKind) {
super(
unfoldableKind,
new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return (input instanceof JetExpression) && BranchedUnfoldingUtils.getUnfoldableExpressionKind((JetExpression) input) == unfoldableKind;
}
}
);
}
public static class UnfoldAssignmentToIfIntention extends UnfoldBranchedExpressionIntention {
public UnfoldAssignmentToIfIntention() {
super(UnfoldableKind.ASSIGNMENT_TO_IF);
}
}
public static class UnfoldPropertyToIfIntention extends UnfoldBranchedExpressionIntention {
public UnfoldPropertyToIfIntention() {
super(UnfoldableKind.PROPERTY_TO_IF);
}
}
public static class UnfoldAssignmentToWhenIntention extends UnfoldBranchedExpressionIntention {
public UnfoldAssignmentToWhenIntention() {
super(UnfoldableKind.ASSIGNMENT_TO_WHEN);
}
}
public static class UnfoldPropertyToWhenIntention extends UnfoldBranchedExpressionIntention {
public UnfoldPropertyToWhenIntention() {
super(UnfoldableKind.PROPERTY_TO_WHEN);
}
}
public static class UnfoldReturnToIfIntention extends UnfoldBranchedExpressionIntention {
public UnfoldReturnToIfIntention() {
super(UnfoldableKind.RETURN_TO_IF);
}
}
public static class UnfoldReturnToWhenIntention extends UnfoldBranchedExpressionIntention {
public UnfoldReturnToWhenIntention() {
super(UnfoldableKind.RETURN_TO_WHEN);
}
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/UnfoldBranchedExpressionIntention.kt
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import com.intellij.psi.PsiElement
import jet.Function1
import org.jetbrains.annotations.Nullable
import org.jetbrains.jet.lang.psi.JetExpression
import org.jetbrains.jet.plugin.intentions.branchedTransformations.*
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import com.intellij.openapi.editor.Editor
import org.jetbrains.jet.lang.psi.JetFile
import org.jetbrains.jet.lang.psi.JetBinaryExpression
import org.jetbrains.jet.lang.psi.JetReturnExpression
import org.jetbrains.jet.lang.psi.JetProperty
public open class UnfoldBranchedExpressionIntention<T: JetExpression>(
val kind: UnfoldableKind, elementType: Class<T>
) : JetSelfTargetingIntention<T>(kind.getKey(), elementType) {
override fun isApplicableTo(element: T): Boolean = BranchedUnfoldingUtils.getUnfoldableExpressionKind(element) == kind
override fun applyTo(element: T, editor: Editor) {
val file = element.getContainingFile()
if (file is JetFile) {
kind.transform(element, editor, file)
}
}
}
public class UnfoldAssignmentToIfIntention : UnfoldBranchedExpressionIntention<JetBinaryExpression>(
UnfoldableKind.ASSIGNMENT_TO_IF, javaClass()
)
public class UnfoldPropertyToIfIntention : UnfoldBranchedExpressionIntention<JetProperty>(
UnfoldableKind.PROPERTY_TO_IF, javaClass()
)
public class UnfoldAssignmentToWhenIntention : UnfoldBranchedExpressionIntention<JetBinaryExpression>(
UnfoldableKind.ASSIGNMENT_TO_WHEN, javaClass()
)
public class UnfoldPropertyToWhenIntention : UnfoldBranchedExpressionIntention<JetProperty>(
UnfoldableKind.PROPERTY_TO_WHEN, javaClass()
)
public class UnfoldReturnToIfIntention : UnfoldBranchedExpressionIntention<JetReturnExpression>(
UnfoldableKind.RETURN_TO_IF, javaClass()
)
public class UnfoldReturnToWhenIntention : UnfoldBranchedExpressionIntention<JetReturnExpression>(
UnfoldableKind.RETURN_TO_WHEN, javaClass()
)
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/WhenToIfIntention.java
-54
View File
@@ -1,54 +0,0 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetWhenExpression;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.branchedTransformations.IfWhenUtils;
import org.jetbrains.jet.plugin.intentions.Transformer;
public class WhenToIfIntention extends AbstractCodeTransformationIntention {
private static final Transformer TRANSFORMER = new Transformer() {
@NotNull
@Override
public String getKey() {
return "when.to.if";
}
@Override
public void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file) {
IfWhenUtils.transformWhenToIf((JetWhenExpression) element);
}
};
private static final Function1<PsiElement, Boolean> IS_APPLICABLE = new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return (input instanceof JetWhenExpression) && IfWhenUtils.checkWhenToIf((JetWhenExpression) input);
}
};
public WhenToIfIntention() {
super(TRANSFORMER, IS_APPLICABLE);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/WhenToIfIntention.kt
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.branchedTransformations.IfWhenUtils
import org.jetbrains.jet.lang.psi.JetWhenExpression
import org.jetbrains.jet.lang.psi.JetIfExpression
import com.intellij.openapi.editor.Editor
public class WhenToIfIntention : JetSelfTargetingIntention<JetWhenExpression>("if.to.when", javaClass()) {
override fun isApplicableTo(element: JetWhenExpression): Boolean = IfWhenUtils.checkWhenToIf(element)
override fun applyTo(element: JetWhenExpression, editor: Editor) {
IfWhenUtils.transformWhenToIf(element)
}
}
idea/src/org/jetbrains/jet/plugin/intentions/declarations/SplitPropertyDeclarationIntention.java
-53
View File
@@ -1,53 +0,0 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.declarations;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetProperty;
import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationIntention;
import org.jetbrains.jet.plugin.intentions.Transformer;
public class SplitPropertyDeclarationIntention extends AbstractCodeTransformationIntention {
private static final Transformer TRANSFORMER = new Transformer() {
@NotNull
@Override
public String getKey() {
return "split.property.declaration";
}
@Override
public void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file) {
DeclarationUtils.splitPropertyDeclaration((JetProperty) element, file);
}
};
private static final Function1<PsiElement, Boolean> IS_APPLICABLE = new Function1<PsiElement, Boolean>() {
@Override
public Boolean invoke(@Nullable PsiElement input) {
return (input instanceof JetProperty) && DeclarationUtils.checkSplitProperty((JetProperty) input);
}
};
public SplitPropertyDeclarationIntention() {
super(TRANSFORMER, IS_APPLICABLE);
}
}
idea/src/org/jetbrains/jet/plugin/intentions/declarations/SplitPropertyDeclarationIntention.kt
+37
View File
@@ -0,0 +1,37 @@
/*
* Copyright 2010-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.plugin.intentions.declarations
import com.intellij.openapi.editor.Editor
import com.intellij.psi.PsiElement
import jet.Function1
import org.jetbrains.annotations.Nullable
import org.jetbrains.jet.lang.psi.JetFile
import org.jetbrains.jet.lang.psi.JetProperty
import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention
import org.jetbrains.jet.plugin.intentions.Transformer
public class SplitPropertyDeclarationIntention : JetSelfTargetingIntention<JetProperty>("split.property.declaration", javaClass()) {
override fun isApplicableTo(element: JetProperty): Boolean = DeclarationUtils.checkSplitProperty(element)
override fun applyTo(element: JetProperty, editor: Editor) {
val file = element.getContainingFile()
if (file is JetFile) {
DeclarationUtils.splitPropertyDeclaration(element, file)
}
}
}
idea/tests/org/jetbrains/jet/plugin/intentions/AbstractCodeTransformationTest.java
+11 -11
View File
@@ -31,47 +31,47 @@ import java.io.File;
public abstract class AbstractCodeTransformationTest extends LightCodeInsightTestCase {
public void doTestFoldIfToAssignment(@NotNull String path) throws Exception {
doTestIntention(path, new FoldBranchedExpressionIntention.FoldIfToAssignmentIntention());
doTestIntention(path, new FoldIfToAssignmentIntention());
}
public void doTestFoldIfToReturn(@NotNull String path) throws Exception {
doTestIntention(path, new FoldBranchedExpressionIntention.FoldIfToReturnIntention());
doTestIntention(path, new FoldIfToReturnIntention());
}
public void doTestFoldIfToReturnAsymmetrically(@NotNull String path) throws Exception {
doTestIntention(path, new FoldBranchedExpressionIntention.FoldIfToReturnAsymmetricallyIntention());
doTestIntention(path, new FoldIfToReturnAsymmetricallyIntention());
}
public void doTestFoldWhenToAssignment(@NotNull String path) throws Exception {
doTestIntention(path, new FoldBranchedExpressionIntention.FoldWhenToAssignmentIntention());
doTestIntention(path, new FoldWhenToAssignmentIntention());
}
public void doTestFoldWhenToReturn(@NotNull String path) throws Exception {
doTestIntention(path, new FoldBranchedExpressionIntention.FoldWhenToReturnIntention());
doTestIntention(path, new FoldWhenToReturnIntention());
}
public void doTestUnfoldAssignmentToIf(@NotNull String path) throws Exception {
doTestIntention(path, new UnfoldBranchedExpressionIntention.UnfoldAssignmentToIfIntention());
doTestIntention(path, new UnfoldAssignmentToIfIntention());
}
public void doTestUnfoldAssignmentToWhen(@NotNull String path) throws Exception {
doTestIntention(path, new UnfoldBranchedExpressionIntention.UnfoldAssignmentToWhenIntention());
doTestIntention(path, new UnfoldAssignmentToWhenIntention());
}
public void doTestUnfoldPropertyToIf(@NotNull String path) throws Exception {
doTestIntention(path, new UnfoldBranchedExpressionIntention.UnfoldPropertyToIfIntention());
doTestIntention(path, new UnfoldPropertyToIfIntention());
}
public void doTestUnfoldPropertyToWhen(@NotNull String path) throws Exception {
doTestIntention(path, new UnfoldBranchedExpressionIntention.UnfoldPropertyToWhenIntention());
doTestIntention(path, new UnfoldPropertyToWhenIntention());
}
public void doTestUnfoldReturnToIf(@NotNull String path) throws Exception {
doTestIntention(path, new UnfoldBranchedExpressionIntention.UnfoldReturnToIfIntention());
doTestIntention(path, new UnfoldReturnToIfIntention());
}
public void doTestUnfoldReturnToWhen(@NotNull String path) throws Exception {
doTestIntention(path, new UnfoldBranchedExpressionIntention.UnfoldReturnToWhenIntention());
doTestIntention(path, new UnfoldReturnToWhenIntention());
}
public void doTestIfToWhen(@NotNull String path) throws Exception {