Implemented Operator To Function intention action.

Converts +a, --a, a * b, a..b, a %= b, a in b, etc. to their function call counterparts.
2014-05-12 18:03:25 +04:00
parent 5550924dc5
commit b3842285e8
45 changed files with 432 additions and 1 deletions
@@ -413,6 +413,7 @@ fun main(args: Array<String>) {
            model("intentions/makeTypeExplicitInLambda", testMethod = "doTestMakeTypeExplicitInLambda")
            model("intentions/makeTypeImplicitInLambda", testMethod = "doTestMakeTypeImplicitInLambda")
            model("intentions/invertIfCondition", testMethod = "doTestInvertIfCondition")
            model("intentions/operatorToFunction", testMethod = "doTestOperatorToFunction")
            model("intentions/convertToForEachLoop", testMethod = "doTestConvertToForEachLoop")
            model("intentions/convertToForEachFunctionCall", testMethod = "doTestConvertToForEachFunctionCall")
        }
@@ -0,0 +1,11 @@
 a.not()
 b.dec()
 a.times(b)
 a.get(i_1, ..., i_n)
 a.set(i_1, ..., i_n, b)
 a.invoke(i_1, ..., i_n)
@@ -0,0 +1,11 @@
 !a
 --b
 a * b
 a[i_1, ..., i_n]
 a[i_1, ..., i_n] = b
 a(i_1, ..., i_n)
@@ -0,0 +1,5 @@
 <html>
 <body>
 Replace overloaded operator with function call
 </body>
 </html>
@@ -706,7 +706,12 @@
      <category>Kotlin</category>
    </intentionAction>
-  <localInspection implementationClass="org.jetbrains.jet.plugin.inspections.ExplicitGetInspection"
+    <intentionAction>
      <className>org.jetbrains.jet.plugin.intentions.OperatorToFunctionIntention</className>
      <category>Kotlin</category>
    </intentionAction>
    <localInspection implementationClass="org.jetbrains.jet.plugin.inspections.ExplicitGetInspection"
        displayName="Explicit 'get'"
        groupName="Kotlin"
        enabledByDefault="true"
@@ -748,6 +753,7 @@
    <project.converterProvider implementation="org.jetbrains.jet.plugin.converters.JetRunConfigurationSettingsFormatConverterProvider"/>
  </extensions>
  <extensionPoints>
@@ -314,6 +314,8 @@ make.type.implicit.in.lambda=Make types implicit in lambda (may break code)
 make.type.implicit.in.lambda.family=Make Types Implicit In Lambda (May Break Code)
 invert.if.condition=Invert If Condition
 invert.if.condition.family=Invert If Condition
 operator.to.function=Replace overloaded operator with function call
 operator.to.function.family=Replace Overloaded Operator With Function Call
 convert.to.for.each.loop.intention=Replace with a for each loop
 convert.to.for.each.loop.intention.family=Replace with a For Each Loop
 convert.to.for.each.function.call.intention=Replace with a forEach function call
@@ -0,0 +1,208 @@
 /*
 * 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.
 * 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 org.jetbrains.jet.lang.psi.JetExpression
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.jet.lang.psi.JetPrefixExpression
 import org.jetbrains.jet.lang.psi.JetPostfixExpression
 import org.jetbrains.jet.lang.psi.JetBinaryExpression
 import org.jetbrains.jet.lang.psi.JetArrayAccessExpression
 import org.jetbrains.jet.lang.psi.JetCallExpression
 import org.jetbrains.jet.lexer.JetTokens
 import org.jetbrains.jet.lang.psi.JetPsiFactory
 import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.psi.psiUtil.getQualifiedElementSelector
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import org.jetbrains.jet.lang.psi.JetFunctionLiteralExpression
 public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpression>("operator.to.function", javaClass()) {
    fun isApplicablePrefix(element: JetPrefixExpression): Boolean {
        return when (element.getOperationReference().getReferencedNameElementType()) {
            JetTokens.PLUS, JetTokens.MINUS, JetTokens.PLUSPLUS, JetTokens.MINUSMINUS, JetTokens.EXCL -> true
            else -> false
        }
    }
    fun isApplicablePostfix(element: JetPostfixExpression): Boolean {
        return when (element.getOperationReference().getReferencedNameElementType()) {
            JetTokens.PLUSPLUS, JetTokens.MINUSMINUS -> true
            else -> false
        }
    }
    fun isApplicableBinary(element: JetBinaryExpression): Boolean {
        return when (element.getOperationReference().getReferencedNameElementType()) {
            JetTokens.PLUS, JetTokens.MINUS, JetTokens.MUL, JetTokens.DIV, JetTokens.PERC, JetTokens.RANGE, JetTokens.IN_KEYWORD, JetTokens.NOT_IN, JetTokens.PLUSEQ, JetTokens.MINUSEQ, JetTokens.MULTEQ, JetTokens.DIVEQ, JetTokens.PERCEQ, JetTokens.EQEQ, JetTokens.EXCLEQ, JetTokens.GT, JetTokens.LT, JetTokens.GTEQ, JetTokens.LTEQ -> true
            JetTokens.EQ -> element.getLeft() is JetArrayAccessExpression
            else -> false
        }
    }
    fun isApplicableCall(element: JetCallExpression): Boolean {
        val resolvedCall = AnalyzerFacadeWithCache.getContextForElement(element)[BindingContext.RESOLVED_CALL, element.getCalleeExpression()]
        val descriptor = resolvedCall?.getResultingDescriptor()
        if (descriptor is FunctionDescriptor && descriptor.getName().asString() == "invoke") {
            val parent = element.getParent()
            if (parent is JetDotQualifiedExpression && element.getCalleeExpression()?.getText() == "invoke") return false
            return !(element.getValueArgumentList() == null && element.getFunctionLiteralArguments().isEmpty())
        }
        return false
    }
    override fun isApplicableTo(element: JetExpression): Boolean {
        return when (element) {
            is JetPrefixExpression -> isApplicablePrefix(element)
            is JetPostfixExpression -> isApplicablePostfix(element)
            is JetBinaryExpression -> isApplicableBinary(element)
            is JetArrayAccessExpression -> true
            is JetCallExpression -> isApplicableCall(element)
            else -> false
        }
    }
    fun convertPrefix(element: JetPrefixExpression) {
        val op = element.getOperationReference().getReferencedNameElementType()
        val base = element.getBaseExpression()!!.getText()
        val call = when (op) {
            JetTokens.PLUS -> "plus()"
            JetTokens.MINUS -> "minus()"
            JetTokens.PLUSPLUS -> "inc()"
            JetTokens.MINUSMINUS -> "dec()"
            JetTokens.EXCL -> "not()"
            else -> return
        }
        val transformation = "$base.$call"
        val transformed = JetPsiFactory.createExpression(element.getProject(), transformation)
        element.replace(transformed)
    }
    fun convertPostFix(element: JetPostfixExpression) {
        val op = element.getOperationReference().getReferencedNameElementType()
        val base = element.getBaseExpression().getText()
        val call = when (op) {
            JetTokens.PLUSPLUS -> "inc()"
            JetTokens.MINUSMINUS -> "dec()"
            else -> return
        }
        val transformation = "$base.$call"
        val transformed = JetPsiFactory.createExpression(element.getProject(), transformation)
        element.replace(transformed)
    }
    fun convertBinary(element: JetBinaryExpression) {
        val op = element.getOperationReference().getReferencedNameElementType()
        val left = element.getLeft()!!
        val right = element.getRight()!!
        val leftText = left.getText()
        val rightText = right.getText()
        if (op == JetTokens.EQ) {
            if (left is JetArrayAccessExpression) {
                convertArrayAccess(left as JetArrayAccessExpression)
            }
            return
        }
        val context = AnalyzerFacadeWithCache.getContextForElement(element)
        val functionCandidate = context[BindingContext.RESOLVED_CALL, element.getOperationReference()]
        val functionName = functionCandidate?.getCandidateDescriptor()?.getName().toString()
        val elemType = context[BindingContext.EXPRESSION_TYPE, left]
        val transformation = when (op) {
            JetTokens.PLUS -> "$leftText.plus($rightText)"
            JetTokens.MINUS -> "$leftText.minus($rightText)"
            JetTokens.MUL -> "$leftText.times($rightText)"
            JetTokens.DIV -> "$leftText.div($rightText)"
            JetTokens.PERC -> "$leftText.mod($rightText)"
            JetTokens.RANGE -> "$leftText.rangeTo($rightText)"
            JetTokens.IN_KEYWORD -> "$rightText.contains($leftText)"
            JetTokens.NOT_IN -> "!$rightText.contains($leftText)"
            JetTokens.PLUSEQ -> if (functionName == "plusAssign") "$leftText.plusAssign($rightText)" else "$leftText = $leftText.plus($rightText)"
            JetTokens.MINUSEQ -> if (functionName == "minusAssign") "$leftText.minusAssign($rightText)" else "$leftText = $leftText.minus($rightText)"
            JetTokens.MULTEQ -> if (functionName == "multAssign") "$leftText.multAssign($rightText)" else "$leftText = $leftText.mult($rightText)"
            JetTokens.DIVEQ -> if (functionName == "divAssign") "$leftText.divAssign($rightText)" else "$leftText = $leftText.div($rightText)"
            JetTokens.PERCEQ -> if (functionName == "modAssign") "$leftText.modAssign($rightText)" else "$leftText = $leftText.mod($rightText)"
            JetTokens.EQEQ -> if (elemType?.isNullable() ?: true) "$leftText?.equals($rightText) ?: $rightText.identityEquals(null)" else "$leftText.equals($rightText)"
            JetTokens.EXCLEQ -> if (elemType?.isNullable() ?: true) "!($leftText?.equals($rightText) ?: $rightText.identityEquals(null))" else "!$leftText.equals($rightText)"
            JetTokens.GT -> "$leftText.compareTo($rightText) > 0"
            JetTokens.LT -> "$leftText.compareTo($rightText) < 0"
            JetTokens.GTEQ -> "$leftText.compareTo($rightText) >= 0"
            JetTokens.LTEQ -> "$leftText.compareTo($rightText) <= 0"
            else -> return
        }
        val transformed = JetPsiFactory.createExpression(element.getProject(), transformation)
        element.replace(transformed)
    }
    fun convertArrayAccess(element: JetArrayAccessExpression) {
        val parent = element.getParent()
        val array = element.getArrayExpression()!!.getText()
        val indices = element.getIndicesNode()
        val indicesText = indices.getText().trim("[","]")
        val transformation : String
        val replaced : JetElement
        if (parent is JetBinaryExpression && parent.getOperationReference().getReferencedNameElementType() == JetTokens.EQ) {
            // part of an assignment
            val right = parent.getRight()!!.getText()
            transformation = "$array.set($indicesText, $right)"
            replaced = parent
        }
        else {
            transformation = "$array.get($indicesText)"
            replaced = element
        }
        val transformed = JetPsiFactory.createExpression(element.getProject(), transformation)
        replaced.replace(transformed)
    }
    fun convertCall(element: JetCallExpression) {
        val callee = element.getCalleeExpression()!!
        val arguments = element.getValueArgumentList()
        val argumentString = arguments?.getText()?.trim("(", ")")
        val funcLitArgs = element.getFunctionLiteralArguments()
        val calleeText = callee.getText()
        val transformation = if (argumentString == null) "$calleeText.invoke" else "$calleeText.invoke($argumentString)"
        val transformed = JetPsiFactory.createExpression(element.getProject(), transformation)
        funcLitArgs.forEach { transformed.add(it) }
        callee.getParent()!!.replace(transformed)
    }
    override fun applyTo(element: JetExpression, editor: Editor) {
        return when (element) {
            is JetPrefixExpression -> convertPrefix(element)
            is JetPostfixExpression -> convertPostFix(element)
            is JetBinaryExpression -> convertBinary(element)
            is JetArrayAccessExpression -> convertArrayAccess(element)
            is JetCallExpression -> convertCall(element)
        }
    }
 }
@@ -0,0 +1,7 @@
 class Bar {
    fun get(vararg args: Int) {}
 }
 fun foo(a: Bar, i: Int) {
    a<caret>[i, 1]
 }
@@ -0,0 +1,7 @@
 class Bar {
    fun get(vararg args: Int) {}
 }
 fun foo(a: Bar, i: Int) {
    a.get(i, 1)
 }
@@ -0,0 +1,3 @@
 fun foo(a: Array<Int>, i: Int) {
    a<caret>[i]
 }
@@ -0,0 +1,3 @@
 fun foo(a: Array<Int>, i: Int) {
    a.get(i)
 }
@@ -0,0 +1,5 @@
 // ERROR: Unresolved reference: array
 fun foo(b: Int) {
    var a = array(1, 2, 3, 4, 5)
    a<caret>[2, 3] = b
 }
@@ -0,0 +1,5 @@
 // ERROR: Unresolved reference: array
 fun foo(b: Int) {
    var a = array(1, 2, 3, 4, 5)
    a.set(2, 3, b)
 }
@@ -0,0 +1,3 @@
 fun foo(a: String?, b: String?) {
    a <caret>== b
 }
@@ -0,0 +1,3 @@
 fun foo(a: String?, b: String?) {
    a?.equals(b) ?: b.identityEquals(null)
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int, b: Int) {
    a !<caret>= b
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int, b: Int) {
    !a.equals(b)
 }
@@ -0,0 +1,4 @@
 // WITH_RUNTIME
 fun foo(a: Int, b: Array<Int>) {
    a <caret>!in b
 }
@@ -0,0 +1,4 @@
 // WITH_RUNTIME
 fun foo(a: Int, b: Array<Int>) {
    !b.contains(a)
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int, b: Int) {
    a <caret>+ b
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int, b: Int) {
    a.plus(b)
 }
@@ -0,0 +1,8 @@
 class Bar {
    fun plusAssign(arg: Bar) {}
 }
 fun foo(b: Bar) {
    var a = Bar()
    a <caret>+= b
 }
@@ -0,0 +1,8 @@
 class Bar {
    fun plusAssign(arg: Bar) {}
 }
 fun foo(b: Bar) {
    var a = Bar()
    a.plusAssign(b)
 }
@@ -0,0 +1,4 @@
 fun foo(b: Int) {
    var a = 0
    a <caret>+= b
 }
@@ -0,0 +1,4 @@
 fun foo(b: Int) {
    var a = 0
    a = a.plus(b)
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int, b: Int) {
    a<caret>..b
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int, b: Int) {
    a.rangeTo(b)
 }
@@ -0,0 +1,9 @@
 class bar() {
    fun invoke(i: Any?, j: Any?) : Boolean {
        return true
    }
 }
 fun foo(i: Any?, j: Any?) {
    val test = bar()<caret>(i, j)
 }
@@ -0,0 +1,9 @@
 class bar() {
    fun invoke(i: Any?, j: Any?) : Boolean {
        return true
    }
 }
 fun foo(i: Any?, j: Any?) {
    val test = bar().invoke(i, j)
 }
@@ -0,0 +1,8 @@
 class Mocha() {
    fun invoke(x: Int, y: String, f: (Int) -> String) {
    }
 }
 fun main() {
    val mocha = Mocha()
    val testing = mocha<caret>(1, "fire"){ (x: Int) -> "hello world" }
 }
@@ -0,0 +1,8 @@
 class Mocha() {
    fun invoke(x: Int, y: String, f: (Int) -> String) {
    }
 }
 fun main() {
    val mocha = Mocha()
    val testing = mocha.invoke(1, "fire"){ (x: Int) -> "hello world" }
 }
@@ -0,0 +1,7 @@
 class Mocha() {
    fun invoke(f: (Int) -> String) {}
 }
 fun main() {
    val mocha = Mocha()
    val testing = mocha<caret>{ (x: Int) -> "hello world" }
 }
@@ -0,0 +1,7 @@
 class Mocha() {
    fun invoke(f: (Int) -> String) {}
 }
 fun main() {
    val mocha = Mocha()
    val testing = mocha.invoke{ (x: Int) -> "hello world" }
 }
@@ -0,0 +1,5 @@
 // IS_APPLICABLE: false
 fun foo(b: Any) {
    var a: Any
    a =<caret> b
 }
@@ -0,0 +1,8 @@
 // IS_APPLICABLE: false
 class coffee() {
    fun invoke() {
    }
 }
 fun main() {
    val f = coffee().<caret>invoke()
 }
@@ -0,0 +1,6 @@
 // WITH_RUNTIME
 // IS_APPLICABLE: false
 fun foo() {
    val bar = { (x: Int) -> x + 1 }
    val incremented = listOf(1, 2, 3).<caret>map(bar)
 }
@@ -0,0 +1,5 @@
 // IS_APPLICABLE: false
 class bar() {}
 fun main() {
    val x = bar<caret>()
 }
@@ -0,0 +1,4 @@
 fun foo() {
    var a = 5
    <caret>a--
 }
@@ -0,0 +1,4 @@
 fun foo() {
    var a = 5
    a.dec()
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int) {
    +<caret>a
 }
@@ -0,0 +1,3 @@
 fun foo(a: Int) {
    a.plus()
 }
@@ -0,0 +1,4 @@
 fun foo() {
    var a = 0
    ++<caret>a
 }
@@ -0,0 +1,4 @@
 fun foo() {
    var a = 0
    a.inc()
 }
@@ -1,5 +1,8 @@
 // "class com.intellij.codeInsight.daemon.impl.quickfix.ImportClassFixBase" "false"
 // ERROR: Unresolved reference: SomeTest
 // ACTION: Edit intention settings
 // ACTION: Replace safe access expression with 'if' expression
 // ACTION: Disable 'Replace Safe Access Expression with 'if' Expression'
 package testing
@@ -270,6 +270,10 @@ public abstract class AbstractCodeTransformationTest extends LightCodeInsightTes
        doTestIntention(path, new MakeTypeImplicitInLambdaIntention());
    }
    public void doTestOperatorToFunction(@NotNull String path) throws Exception {
        doTestIntention(path, new OperatorToFunctionIntention());
    }
    public void doTestConvertToForEachLoop(@NotNull String path) throws Exception {
        doTestIntention(path, new ConvertToForEachLoopIntention());
    }