diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixRegistrar.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixRegistrar.java index c10962ecd42..3198faf5c66 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixRegistrar.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixRegistrar.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.plugin.quickfix; import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.plugin.codeInsight.ImplementMethodsHandler; -import org.jetbrains.jet.plugin.quickfix.createFromUsage.CreateFunctionFromUsageFix; +import org.jetbrains.jet.plugin.quickfix.createFromUsage.*; import static org.jetbrains.jet.lang.diagnostics.Errors.*; import static org.jetbrains.jet.lexer.JetTokens.*; @@ -230,15 +230,13 @@ public class QuickFixRegistrar { QuickFixes.factories.put(MANY_CLASSES_IN_SUPERTYPE_LIST, RemoveSupertypeFix.createFactory()); - QuickFixes.factories.put(NO_GET_METHOD, CreateFunctionFromUsageFix.OBJECT$.createCreateGetFunctionFromUsageFactory()); - QuickFixes.factories.put(NO_SET_METHOD, CreateFunctionFromUsageFix.OBJECT$.createCreateSetFunctionFromUsageFactory()); - JetSingleIntentionActionFactory createHasNextFromUsageFactory = CreateFunctionFromUsageFix.OBJECT$.createCreateHasNextFunctionFromUsageFactory(); - QuickFixes.factories.put(HAS_NEXT_MISSING, createHasNextFromUsageFactory); - QuickFixes.factories.put(HAS_NEXT_FUNCTION_NONE_APPLICABLE, createHasNextFromUsageFactory); - JetSingleIntentionActionFactory createNextFromUsageFactory = CreateFunctionFromUsageFix.OBJECT$.createCreateNextFunctionFromUsageFactory(); - QuickFixes.factories.put(NEXT_MISSING, createNextFromUsageFactory); - QuickFixes.factories.put(NEXT_NONE_APPLICABLE, createNextFromUsageFactory); - QuickFixes.factories.put(ITERATOR_MISSING, CreateFunctionFromUsageFix.OBJECT$.createCreateIteratorFunctionFromUsageFactory()); - QuickFixes.factories.put(COMPONENT_FUNCTION_MISSING, CreateFunctionFromUsageFix.OBJECT$.createCreateComponentFunctionFromUsageFactory()); + QuickFixes.factories.put(NO_GET_METHOD, CreateGetFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(NO_SET_METHOD, CreateSetFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(HAS_NEXT_MISSING, CreateHasNextFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(HAS_NEXT_FUNCTION_NONE_APPLICABLE, CreateHasNextFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(NEXT_MISSING, CreateNextFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(NEXT_NONE_APPLICABLE, CreateNextFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(ITERATOR_MISSING, CreateIteratorFunctionActionFactory.INSTANCE$); + QuickFixes.factories.put(COMPONENT_FUNCTION_MISSING, CreateComponentFunctionActionFactory.INSTANCE$); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateComponentFunctionActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateComponentFunctionActionFactory.kt new file mode 100644 index 00000000000..42df188900c --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateComponentFunctionActionFactory.kt @@ -0,0 +1,38 @@ +package org.jetbrains.jet.plugin.quickfix.createFromUsage + +import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory +import org.jetbrains.jet.lang.diagnostics.Diagnostic +import com.intellij.codeInsight.intention.IntentionAction +import org.jetbrains.jet.lang.resolve.dataClassUtils.* +import org.jetbrains.jet.lang.diagnostics.Errors +import org.jetbrains.jet.plugin.quickfix.QuickFixUtil +import org.jetbrains.jet.lang.psi.JetMultiDeclaration +import org.jetbrains.jet.lang.psi.JetForExpression +import org.jetbrains.jet.lang.types.Variance + +object CreateComponentFunctionActionFactory : JetSingleIntentionActionFactory() { + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val diagnosticWithParameters = Errors.COMPONENT_FUNCTION_MISSING.cast(diagnostic) + val name = diagnosticWithParameters.getA() + if (!isComponentLike(name)) return null + + val componentNumber = getComponentIndex(name) - 1 + + var multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) + val ownerType = if (multiDeclaration == null) { + val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass())!! + multiDeclaration = forExpr.getMultiParameter()!! + TypeOrExpressionThereof(diagnosticWithParameters.getB(), Variance.IN_VARIANCE) + } + else { + val rhs = multiDeclaration!!.getInitializer() ?: return null + TypeOrExpressionThereof(rhs, Variance.IN_VARIANCE) + } + val entries = multiDeclaration!!.getEntries() + + val entry = entries[componentNumber] + val returnType = TypeOrExpressionThereof(entry, Variance.OUT_VARIANCE) + + return CreateFunctionFromUsageFix(multiDeclaration!!, ownerType, name.getIdentifier(), returnType) + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateFunctionFromUsageFix.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateFunctionFromUsageFix.kt index 95aa5804a34..cbf1b64e1bc 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateFunctionFromUsageFix.kt +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateFunctionFromUsageFix.kt @@ -16,7 +16,6 @@ package org.jetbrains.jet.plugin.quickfix.createFromUsage -import com.intellij.codeInsight.intention.IntentionAction import com.intellij.codeInsight.lookup.LookupElement import com.intellij.codeInsight.lookup.LookupElementBuilder import com.intellij.codeInsight.navigation.NavigationUtil @@ -41,8 +40,6 @@ import com.intellij.ui.components.JBList import com.intellij.util.ArrayUtil import com.intellij.util.IncorrectOperationException import org.jetbrains.jet.lang.descriptors.* -import org.jetbrains.jet.lang.diagnostics.Diagnostic -import org.jetbrains.jet.lang.diagnostics.Errors import org.jetbrains.jet.lang.psi.* import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.resolve.DescriptorUtils @@ -58,7 +55,6 @@ import org.jetbrains.jet.plugin.refactoring.JetNameSuggester import org.jetbrains.jet.plugin.refactoring.JetNameValidator import org.jetbrains.jet.plugin.references.JetSimpleNameReference import javax.swing.* -import java.util.regex.Pattern import kotlin.properties.Delegates import java.util.LinkedHashSet import java.util.Collections @@ -67,12 +63,7 @@ import java.util.HashMap import java.util.ArrayList import java.util.Properties import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults -import org.jetbrains.jet.plugin.caches.resolve.getBindingContext -import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils -import org.jetbrains.jet.lang.resolve.dataClassUtils.isComponentLike -import org.jetbrains.jet.lang.resolve.dataClassUtils.getComponentIndex -import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory import org.jetbrains.jet.plugin.quickfix.QuickFixUtil private val TYPE_PARAMETER_LIST_VARIABLE_NAME = "typeParameterList" @@ -871,124 +862,5 @@ public class CreateFunctionFromUsageFix internal ( val fullyQualifiedReceiverTypeRef = JetPsiFactory(typeRef).createType(theType.renderLong(typeParameterNameMap)) typeRef.replace(fullyQualifiedReceiverTypeRef) } - - class object { - public fun createCreateGetFunctionFromUsageFactory(): JetSingleIntentionActionFactory { - return object : JetSingleIntentionActionFactory() { - override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val accessExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null - val arrayExpr = accessExpr.getArrayExpression() ?: return null - val arrayType = TypeOrExpressionThereof(arrayExpr, Variance.IN_VARIANCE) - - val parameters = accessExpr.getIndexExpressions().map { - Parameter(TypeOrExpressionThereof(it, Variance.IN_VARIANCE)) - } - - val returnType = TypeOrExpressionThereof(accessExpr, Variance.OUT_VARIANCE) - return CreateFunctionFromUsageFix(accessExpr, arrayType, "get", returnType, parameters) - } - } - } - - public fun createCreateSetFunctionFromUsageFactory(): JetSingleIntentionActionFactory { - return object : JetSingleIntentionActionFactory() { - override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val accessExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null - val arrayExpr = accessExpr.getArrayExpression() ?: return null - val arrayType = TypeOrExpressionThereof(arrayExpr, Variance.IN_VARIANCE) - - val parameters = accessExpr.getIndexExpressions().mapTo(ArrayList()) { - Parameter(TypeOrExpressionThereof(it, Variance.IN_VARIANCE)) - } - - val assignmentExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null - val rhs = assignmentExpr.getRight() ?: return null - val valType = TypeOrExpressionThereof(rhs, Variance.IN_VARIANCE) - parameters.add(Parameter(valType, "value")) - - val returnType = TypeOrExpressionThereof(KotlinBuiltIns.getInstance().getUnitType(), Variance.OUT_VARIANCE) - return CreateFunctionFromUsageFix(accessExpr, arrayType, "set", returnType, parameters) - } - } - } - - public fun createCreateHasNextFunctionFromUsageFactory(): JetSingleIntentionActionFactory { - return object : JetSingleIntentionActionFactory() { - override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val diagnosticWithParameters = DiagnosticFactory.cast(diagnostic, Errors.HAS_NEXT_MISSING, Errors.HAS_NEXT_FUNCTION_NONE_APPLICABLE) - val ownerType = TypeOrExpressionThereof(diagnosticWithParameters.getA(), Variance.IN_VARIANCE) - - val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null - val returnType = TypeOrExpressionThereof(KotlinBuiltIns.getInstance().getBooleanType(), Variance.OUT_VARIANCE) - return CreateFunctionFromUsageFix(forExpr, ownerType, "hasNext", returnType) - } - } - } - - public fun createCreateNextFunctionFromUsageFactory(): JetSingleIntentionActionFactory { - return object : JetSingleIntentionActionFactory() { - override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val diagnosticWithParameters = DiagnosticFactory.cast(diagnostic, Errors.NEXT_MISSING, Errors.NEXT_NONE_APPLICABLE) - val ownerType = TypeOrExpressionThereof(diagnosticWithParameters.getA(), Variance.IN_VARIANCE) - - val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null - val variableExpr: JetExpression = ((forExpr.getLoopParameter() ?: forExpr.getMultiParameter()) ?: return null) as JetExpression - val returnType = TypeOrExpressionThereof(variableExpr, Variance.OUT_VARIANCE) - return CreateFunctionFromUsageFix(forExpr, ownerType, "next", returnType) - } - } - } - - public fun createCreateIteratorFunctionFromUsageFactory(): JetSingleIntentionActionFactory { - return object : JetSingleIntentionActionFactory() { - override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val file = diagnostic.getPsiFile() as? JetFile ?: return null - val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null - val iterableExpr = forExpr.getLoopRange() ?: return null - val variableExpr: JetExpression = ((forExpr.getLoopParameter() ?: forExpr.getMultiParameter()) ?: return null) as JetExpression - val iterableType = TypeOrExpressionThereof(iterableExpr, Variance.IN_VARIANCE) - val returnJetType = KotlinBuiltIns.getInstance().getIterator().getDefaultType() - - val context = file.getBindingContext() - val returnJetTypeParameterTypes = variableExpr.guessTypes(context) - if (returnJetTypeParameterTypes.size != 1) return null - - val returnJetTypeParameterType = TypeProjectionImpl(returnJetTypeParameterTypes[0]) - val returnJetTypeArguments = Collections.singletonList(returnJetTypeParameterType) - val newReturnJetType = JetTypeImpl(returnJetType.getAnnotations(), returnJetType.getConstructor(), returnJetType.isNullable(), returnJetTypeArguments, returnJetType.getMemberScope()) - val returnType = TypeOrExpressionThereof(newReturnJetType, Variance.OUT_VARIANCE) - return CreateFunctionFromUsageFix(forExpr, iterableType, "iterator", returnType) - } - } - } - - public fun createCreateComponentFunctionFromUsageFactory(): JetSingleIntentionActionFactory { - return object : JetSingleIntentionActionFactory() { - override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val diagnosticWithParameters = Errors.COMPONENT_FUNCTION_MISSING.cast(diagnostic) - val name = diagnosticWithParameters.getA() - if (!isComponentLike(name)) return null - - val componentNumber = getComponentIndex(name) - 1 - - var multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) - val ownerType = if (multiDeclaration == null) { - val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass())!! - multiDeclaration = forExpr.getMultiParameter()!! - TypeOrExpressionThereof(diagnosticWithParameters.getB(), Variance.IN_VARIANCE) - } - else { - val rhs = multiDeclaration!!.getInitializer() ?: return null - TypeOrExpressionThereof(rhs, Variance.IN_VARIANCE) - } - val entries = multiDeclaration!!.getEntries() - - val entry = entries[componentNumber] - val returnType = TypeOrExpressionThereof(entry, Variance.OUT_VARIANCE) - - return CreateFunctionFromUsageFix(multiDeclaration!!, ownerType, name.getIdentifier(), returnType) - } - } - } - } } + diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateGetFunctionActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateGetFunctionActionFactory.kt new file mode 100644 index 00000000000..6ea7ab186d4 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateGetFunctionActionFactory.kt @@ -0,0 +1,23 @@ +package org.jetbrains.jet.plugin.quickfix.createFromUsage + +import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory +import org.jetbrains.jet.lang.diagnostics.Diagnostic +import com.intellij.codeInsight.intention.IntentionAction +import org.jetbrains.jet.plugin.quickfix.QuickFixUtil +import org.jetbrains.jet.lang.psi.JetArrayAccessExpression +import org.jetbrains.jet.lang.types.Variance + +object CreateGetFunctionActionFactory : JetSingleIntentionActionFactory() { + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val accessExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null + val arrayExpr = accessExpr.getArrayExpression() ?: return null + val arrayType = TypeOrExpressionThereof(arrayExpr, Variance.IN_VARIANCE) + + val parameters = accessExpr.getIndexExpressions().map { + Parameter(TypeOrExpressionThereof(it, Variance.IN_VARIANCE)) + } + + val returnType = TypeOrExpressionThereof(accessExpr, Variance.OUT_VARIANCE) + return CreateFunctionFromUsageFix(accessExpr, arrayType, "get", returnType, parameters) + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateHasNextFunctionActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateHasNextFunctionActionFactory.kt new file mode 100644 index 00000000000..078558c3a7a --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateHasNextFunctionActionFactory.kt @@ -0,0 +1,22 @@ +package org.jetbrains.jet.plugin.quickfix.createFromUsage + +import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory +import org.jetbrains.jet.lang.diagnostics.Diagnostic +import com.intellij.codeInsight.intention.IntentionAction +import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory +import org.jetbrains.jet.lang.diagnostics.Errors +import org.jetbrains.jet.lang.types.Variance +import org.jetbrains.jet.plugin.quickfix.QuickFixUtil +import org.jetbrains.jet.lang.psi.JetForExpression +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns + +object CreateHasNextFunctionActionFactory : JetSingleIntentionActionFactory() { + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val diagnosticWithParameters = DiagnosticFactory.cast(diagnostic, Errors.HAS_NEXT_MISSING, Errors.HAS_NEXT_FUNCTION_NONE_APPLICABLE) + val ownerType = TypeOrExpressionThereof(diagnosticWithParameters.getA(), Variance.IN_VARIANCE) + + val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null + val returnType = TypeOrExpressionThereof(KotlinBuiltIns.getInstance().getBooleanType(), Variance.OUT_VARIANCE) + return CreateFunctionFromUsageFix(forExpr, ownerType, "hasNext", returnType) + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateIteratorFunctionActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateIteratorFunctionActionFactory.kt new file mode 100644 index 00000000000..d61d60ddadf --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateIteratorFunctionActionFactory.kt @@ -0,0 +1,36 @@ +package org.jetbrains.jet.plugin.quickfix.createFromUsage + +import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory +import org.jetbrains.jet.lang.diagnostics.Diagnostic +import com.intellij.codeInsight.intention.IntentionAction +import org.jetbrains.jet.lang.psi.JetFile +import org.jetbrains.jet.plugin.quickfix.QuickFixUtil +import org.jetbrains.jet.lang.psi.JetForExpression +import org.jetbrains.jet.lang.psi.JetExpression +import org.jetbrains.jet.lang.types.Variance +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns +import org.jetbrains.jet.plugin.caches.resolve.getBindingContext +import org.jetbrains.jet.lang.types.TypeProjectionImpl +import java.util.Collections +import org.jetbrains.jet.lang.types.JetTypeImpl + +object CreateIteratorFunctionActionFactory : JetSingleIntentionActionFactory() { + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val file = diagnostic.getPsiFile() as? JetFile ?: return null + val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null + val iterableExpr = forExpr.getLoopRange() ?: return null + val variableExpr: JetExpression = ((forExpr.getLoopParameter() ?: forExpr.getMultiParameter()) ?: return null) as JetExpression + val iterableType = TypeOrExpressionThereof(iterableExpr, Variance.IN_VARIANCE) + val returnJetType = KotlinBuiltIns.getInstance().getIterator().getDefaultType() + + val context = file.getBindingContext() + val returnJetTypeParameterTypes = variableExpr.guessTypes(context) + if (returnJetTypeParameterTypes.size != 1) return null + + val returnJetTypeParameterType = TypeProjectionImpl(returnJetTypeParameterTypes[0]) + val returnJetTypeArguments = Collections.singletonList(returnJetTypeParameterType) + val newReturnJetType = JetTypeImpl(returnJetType.getAnnotations(), returnJetType.getConstructor(), returnJetType.isNullable(), returnJetTypeArguments, returnJetType.getMemberScope()) + val returnType = TypeOrExpressionThereof(newReturnJetType, Variance.OUT_VARIANCE) + return CreateFunctionFromUsageFix(forExpr, iterableType, "iterator", returnType) + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateNextFunctionActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateNextFunctionActionFactory.kt new file mode 100644 index 00000000000..862ebdbcc55 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateNextFunctionActionFactory.kt @@ -0,0 +1,23 @@ +package org.jetbrains.jet.plugin.quickfix.createFromUsage + +import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory +import org.jetbrains.jet.lang.diagnostics.Diagnostic +import com.intellij.codeInsight.intention.IntentionAction +import org.jetbrains.jet.lang.psi.JetExpression +import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory +import org.jetbrains.jet.lang.diagnostics.Errors +import org.jetbrains.jet.lang.types.Variance +import org.jetbrains.jet.plugin.quickfix.QuickFixUtil +import org.jetbrains.jet.lang.psi.JetForExpression + +object CreateNextFunctionActionFactory : JetSingleIntentionActionFactory() { + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val diagnosticWithParameters = DiagnosticFactory.cast(diagnostic, Errors.NEXT_MISSING, Errors.NEXT_NONE_APPLICABLE) + val ownerType = TypeOrExpressionThereof(diagnosticWithParameters.getA(), Variance.IN_VARIANCE) + + val forExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null + val variableExpr: JetExpression = ((forExpr.getLoopParameter() ?: forExpr.getMultiParameter()) ?: return null) as JetExpression + val returnType = TypeOrExpressionThereof(variableExpr, Variance.OUT_VARIANCE) + return CreateFunctionFromUsageFix(forExpr, ownerType, "next", returnType) + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateSetFunctionActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateSetFunctionActionFactory.kt new file mode 100644 index 00000000000..f15611048cb --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/CreateSetFunctionActionFactory.kt @@ -0,0 +1,31 @@ +package org.jetbrains.jet.plugin.quickfix.createFromUsage + +import org.jetbrains.jet.plugin.quickfix.JetSingleIntentionActionFactory +import org.jetbrains.jet.lang.diagnostics.Diagnostic +import com.intellij.codeInsight.intention.IntentionAction +import org.jetbrains.jet.plugin.quickfix.QuickFixUtil +import org.jetbrains.jet.lang.psi.JetArrayAccessExpression +import org.jetbrains.jet.lang.types.Variance +import java.util.ArrayList +import org.jetbrains.jet.lang.psi.JetBinaryExpression +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns + +object CreateSetFunctionActionFactory : JetSingleIntentionActionFactory() { + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val accessExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null + val arrayExpr = accessExpr.getArrayExpression() ?: return null + val arrayType = TypeOrExpressionThereof(arrayExpr, Variance.IN_VARIANCE) + + val parameters = accessExpr.getIndexExpressions().mapTo(ArrayList()) { + Parameter(TypeOrExpressionThereof(it, Variance.IN_VARIANCE)) + } + + val assignmentExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null + val rhs = assignmentExpr.getRight() ?: return null + val valType = TypeOrExpressionThereof(rhs, Variance.IN_VARIANCE) + parameters.add(Parameter(valType, "value")) + + val returnType = TypeOrExpressionThereof(KotlinBuiltIns.getInstance().getUnitType(), Variance.OUT_VARIANCE) + return CreateFunctionFromUsageFix(accessExpr, arrayType, "set", returnType, parameters) + } +} \ No newline at end of file