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

Added more quickfixes; added tests

Browse Source
This commit is contained in:
svtk
2011-09-21 17:58:44 +04:00
parent e6c871aecc
commit 7f815176f6
96 changed files with 1357 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
+9 -7
View File
@@ -90,13 +90,15 @@ public class JetPsiChecker implements Annotator {
DiagnosticWithPsiElement diagnosticWithPsiElement = (DiagnosticWithPsiElement) diagnostic;
if (diagnostic.getFactory() instanceof PsiElementOnlyDiagnosticFactory) {
PsiElementOnlyDiagnosticFactory factory = (PsiElementOnlyDiagnosticFactory) diagnostic.getFactory();
IntentionActionFactory intentionActionFactory = QuickFixes.get(factory);
IntentionAction action = null;
if (intentionActionFactory != null) {
action = intentionActionFactory.createAction(diagnosticWithPsiElement);
}
if (action != null) {
annotation.registerFix(action);
Set<IntentionActionFactory> intentionActionFactories = QuickFixes.get(factory);
for (IntentionActionFactory intentionActionFactory : intentionActionFactories) {
IntentionAction action = null;
if (intentionActionFactory != null) {
action = intentionActionFactory.createAction(diagnosticWithPsiElement);
}
if (action != null) {
annotation.registerFix(action);
}
}
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java
+61
View File
@@ -0,0 +1,61 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiWhiteSpace;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
*/
public class AddFunctionBodyFix extends IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> {
public AddFunctionBodyFix(@NotNull JetFunctionOrPropertyAccessor element) {
super(element);
}
@NotNull
@Override
public String getText() {
return "Add function body";
}
@NotNull
@Override
public String getFamilyName() {
return "Add function body";
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return super.isAvailable(project, editor, file) &&
element.getBodyExpression() == null;
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
JetFunctionOrPropertyAccessor newElement = (JetFunctionOrPropertyAccessor) element.copy();
JetExpression bodyExpression = newElement.getBodyExpression();
if (!(newElement.getLastChild() instanceof PsiWhiteSpace)) {
newElement.add(JetPsiFactory.createWhiteSpace(project));
}
if (bodyExpression == null) {
newElement.add(JetPsiFactory.createEmptyBody(project));
}
element.replace(newElement);
}
public static IntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
return new IntentionActionFactory<JetFunctionOrPropertyAccessor>() {
@Override
public IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetFunctionOrPropertyAccessor;
return new AddFunctionBodyFix((JetFunctionOrPropertyAccessor) diagnostic.getPsiElement());
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
+25 -9
View File
@@ -7,7 +7,9 @@ import com.intellij.psi.PsiFile;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.psi.JetModifierList;
import org.jetbrains.jet.lang.psi.JetModifierListOwner;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lexer.JetKeywordToken;
import org.jetbrains.jet.lexer.JetToken;
import org.jetbrains.jet.lexer.JetTokens;
@@ -17,27 +19,41 @@ import org.jetbrains.jet.lexer.JetTokens;
*/
public class AddModifierFix extends ModifierFix {
private final JetToken[] modifiersThanCanBeReplaced;
private final JetToken[] conflictedModifiers;
private AddModifierFix(@NotNull JetModifierListOwner element, JetKeywordToken modifier, JetToken[] modifiersThanCanBeReplaced) {
private AddModifierFix(@NotNull JetModifierListOwner element, JetKeywordToken modifier, JetToken[] modifiersThanCanBeReplaced, JetToken[] conflictedModifiers) {
super(element, modifier);
this.modifiersThanCanBeReplaced = modifiersThanCanBeReplaced;
this.conflictedModifiers = conflictedModifiers;
}
private static boolean checkConflictModifiers(JetModifierListOwner element, JetToken[] conflictedModifiers) {
for (JetToken conflictedModifier : conflictedModifiers) {
if (element.hasModifier(conflictedModifier)) {
return true;
}
}
return false;
}
@NotNull
@Override
public String getText() {
return "add." + modifier.getValue() + ".modifier.fix";
if (modifier == JetTokens.ABSTRACT_KEYWORD) {
return "Make " + getElementName() + " " + modifier.getValue();
}
return "Add '" + modifier.getValue() + "' modifier";
}
@NotNull
@Override
public String getFamilyName() {
return "add." + modifier.getValue() + ".modifier.family";
return "Add modifier";
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return super.isAvailable(project, editor, file) && !element.hasModifier(JetTokens.FINAL_KEYWORD);
return element.isValid() && !checkConflictModifiers(element, conflictedModifiers);
}
@Override
@@ -81,17 +97,17 @@ public class AddModifierFix extends ModifierFix {
return true;
}
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier, final JetToken[] modifiersThatCanBeReplaced) {
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier, final JetToken[] modifiersThatCanBeReplaced, final JetToken[] conflictedModifiers) {
return new IntentionActionFactory<JetModifierListOwner>() {
@Override
public IntentionActionForPsiElement<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetModifierListOwner;
return new AddModifierFix((JetModifierListOwner) diagnostic.getPsiElement(), modifier, modifiersThatCanBeReplaced);
return new AddModifierFix((JetModifierListOwner) diagnostic.getPsiElement(), modifier, modifiersThatCanBeReplaced, conflictedModifiers);
}
};
}
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
return createFactory(modifier, new JetToken[] {});
return createFactory(modifier, new JetToken[0], new JetToken[0]);
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java
+72
View File
@@ -0,0 +1,72 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetParameter;
import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.psi.JetTypeReference;
import org.jetbrains.jet.lang.types.JetType;
/**
* @author svtk
*/
public class ChangeAccessorTypeFix extends IntentionActionForPsiElement<JetPropertyAccessor> {
private final JetType type;
public ChangeAccessorTypeFix(@NotNull JetPropertyAccessor element, JetType type) {
super(element);
this.type = type;
}
@NotNull
@Override
public String getText() {
return (element.isGetter() ? "Change getter " : "Change setter parameter ") + "type to " + type;
}
@NotNull
@Override
public String getFamilyName() {
return "Change accessor type";
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
JetPropertyAccessor newElement = (JetPropertyAccessor) element.copy();
JetTypeReference newTypeReference = JetPsiFactory.createType(project, type.toString());
if (element.isGetter()) {
JetTypeReference returnTypeReference = newElement.getReturnTypeReference();
assert returnTypeReference != null;
CodeEditUtil.replaceChild(newElement.getNode(), returnTypeReference.getNode(), newTypeReference.getNode());
element.replace(newElement);
}
else {
JetParameter parameter = newElement.getParameter();
assert parameter != null;
JetTypeReference typeReference = parameter.getTypeReference();
assert typeReference != null;
CodeEditUtil.replaceChild(parameter.getNode(), typeReference.getNode(), newTypeReference.getNode());
element.replace(newElement);
}
}
public static IntentionActionFactory<JetPropertyAccessor> createFactory() {
return new IntentionActionFactory<JetPropertyAccessor>() {
@Override
public IntentionActionForPsiElement<JetPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
assert diagnostic.getPsiElement() instanceof JetPropertyAccessor;
assert ((DiagnosticWithAdditionalInfo) diagnostic).getInfo() instanceof JetType;
return new ChangeAccessorTypeFix((JetPropertyAccessor) diagnostic.getPsiElement(), (JetType) ((DiagnosticWithAdditionalInfo) diagnostic).getInfo());
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java
+64
View File
@@ -0,0 +1,64 @@
package org.jetbrains.jet.plugin.quickfix;
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.psi.impl.source.codeStyle.CodeEditUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetProperty;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
*/
public class ChangeVariableMutabilityFix extends IntentionActionForPsiElement<JetProperty> {
public ChangeVariableMutabilityFix(@NotNull JetProperty element) {
super(element);
}
@NotNull
@Override
public String getText() {
return "Make variable " + (element.isVar() ? "immutable" : "mutable");
}
@NotNull
@Override
public String getFamilyName() {
return "Change variable mutability";
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
JetProperty newElement = (JetProperty) element.copy();
if (newElement.isVar()) {
PsiElement varElement = newElement.getNode().findChildByType(JetTokens.VAR_KEYWORD).getPsi();
JetProperty valProperty = JetPsiFactory.createProperty(project, "x", "Any", false);
PsiElement valElement = valProperty.getNode().findChildByType(JetTokens.VAL_KEYWORD).getPsi();
CodeEditUtil.replaceChild(newElement.getNode(), varElement.getNode(), valElement.getNode());
}
else {
PsiElement valElement = newElement.getNode().findChildByType(JetTokens.VAL_KEYWORD).getPsi();
JetProperty varProperty = JetPsiFactory.createProperty(project, "x", "Any", true);
PsiElement varElement = varProperty.getNode().findChildByType(JetTokens.VAR_KEYWORD).getPsi();
CodeEditUtil.replaceChild(newElement.getNode(), valElement.getNode(), varElement.getNode());
}
element.replace(newElement);
}
public static IntentionActionFactory<JetProperty> createFactory() {
return new IntentionActionFactory<JetProperty>() {
@Override
public IntentionActionForPsiElement<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetProperty;
return new ChangeVariableMutabilityFix((JetProperty) diagnostic.getPsiElement());
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/IntentionActionFactory.java
+1 -1
View File
@@ -8,6 +8,6 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
*/
public interface IntentionActionFactory<T extends PsiElement> {
IntentionActionForPsiElement createAction(DiagnosticWithPsiElement diagnostic);
IntentionActionForPsiElement<T> createAction(DiagnosticWithPsiElement diagnostic);
}
idea/src/org/jetbrains/jet/plugin/quickfix/IntentionActionForPsiElement.java
+13
View File
@@ -1,7 +1,10 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.intention.IntentionAction;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
/**
@@ -13,4 +16,14 @@ public abstract class IntentionActionForPsiElement<T extends PsiElement> impleme
public IntentionActionForPsiElement(@NotNull T element) {
this.element = element;
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return element.isValid();
}
@Override
public boolean startInWriteAction() {
return true;
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/ModifierFix.java
+11 -12
View File
@@ -1,8 +1,7 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiNameIdentifierOwner;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.psi.JetModifierListOwner;
import org.jetbrains.jet.lexer.JetKeywordToken;
@@ -18,14 +17,14 @@ public abstract class ModifierFix extends IntentionActionForPsiElement<JetModifi
this.modifier = modifier;
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return element.isValid();
@NotNull
protected String getElementName() {
if (element instanceof PsiNameIdentifierOwner) {
PsiElement nameIdentifier = ((PsiNameIdentifierOwner) element).getNameIdentifier();
if (nameIdentifier != null) {
return "'" + nameIdentifier.getText() + "'";
}
}
return "'" + element.getText() + "'";
}
@Override
public boolean startInWriteAction() {
return true;
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java
+33
View File
@@ -0,0 +1,33 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.psi.PsiElement;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElementImpl;
/**
* @author svtk
*/
public class QuickFixUtil {
private QuickFixUtil() {}
public static <T extends PsiElement> IntentionActionFactory<T> createFactoryRedirectingAdditionalInfoToAnotherFactory(final IntentionActionFactory<T> factory) {
return new IntentionActionFactory<T>() {
@Override
public IntentionActionForPsiElement<T> createAction(DiagnosticWithPsiElement diagnostic) {
//no type check; should be followed manually
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
Object info = ((DiagnosticWithAdditionalInfo) diagnostic).getInfo();
T element = null;
try {
element = (T) info;
}
catch (ClassCastException ex) {
assert false : ex;
}
return factory.createAction(new DiagnosticWithPsiElementImpl<T>(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), element));
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java
+56 -7
View File
@@ -1,39 +1,88 @@
package org.jetbrains.jet.plugin.quickfix;
import com.google.common.collect.Maps;
import com.google.common.collect.HashMultimap;
import com.intellij.psi.PsiElement;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.diagnostics.PsiElementOnlyDiagnosticFactory;
import org.jetbrains.jet.lang.psi.JetFunctionOrPropertyAccessor;
import org.jetbrains.jet.lang.psi.JetModifierListOwner;
import org.jetbrains.jet.lang.psi.JetProperty;
import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
import org.jetbrains.jet.lexer.JetToken;
import org.jetbrains.jet.lexer.JetTokens;
import java.util.Map;
import java.util.Set;
/**
* @author svtk
*/
public class QuickFixes {
private static Map<PsiElementOnlyDiagnosticFactory, IntentionActionFactory> actionMap = Maps.newHashMap();
private static HashMultimap<PsiElementOnlyDiagnosticFactory, IntentionActionFactory> actionMap = HashMultimap.create();
public static IntentionActionFactory get(PsiElementOnlyDiagnosticFactory diagnosticFactory) {
public static Set<IntentionActionFactory> get(PsiElementOnlyDiagnosticFactory diagnosticFactory) {
return actionMap.get(diagnosticFactory);
}
private QuickFixes() {}
private static <T extends PsiElement> void add(PsiElementOnlyDiagnosticFactory<T> diagnosticFactory, IntentionActionFactory<T> actionFactory) {
private static <T extends PsiElement> void add(PsiElementOnlyDiagnosticFactory<? extends T> diagnosticFactory, IntentionActionFactory<T> actionFactory) {
actionMap.put(diagnosticFactory, actionFactory);
}
static {
IntentionActionFactory<JetModifierListOwner> removeAbstractModifierFactory = RemoveModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD);
IntentionActionFactory<JetModifierListOwner> addAbstractModifierFactory = AddModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD, new JetToken[]{JetTokens.OPEN_KEYWORD});
IntentionActionFactory<JetModifierListOwner> addAbstractModifierFactory = AddModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD, new JetToken[]{JetTokens.OPEN_KEYWORD}, new JetToken[] {JetTokens.FINAL_KEYWORD});
add(Errors.ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_NOT_IN_CLASS, removeAbstractModifierFactory);
IntentionActionFactory<JetProperty> removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory();
add(Errors.ABSTRACT_PROPERTY_WITH_INITIALIZER, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_INITIALIZER, removePartsFromPropertyFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_GETTER, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_GETTER, removePartsFromPropertyFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_SETTER, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_SETTER, removePartsFromPropertyFactory);
add(Errors.MUST_BE_INITIALIZED_OR_BE_ABSTRACT, addAbstractModifierFactory);
add(Errors.REDUNDANT_ABSTRACT, removeAbstractModifierFactory);
IntentionActionFactory<JetModifierListOwner> addAbstractToClassFactory = QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
IntentionActionFactory<JetFunctionOrPropertyAccessor> removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory();
add(Errors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
add(Errors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
add(Errors.ABSTRACT_FUNCTION_WITH_BODY, removeAbstractModifierFactory);
add(Errors.ABSTRACT_FUNCTION_WITH_BODY, removeFunctionBodyFactory);
IntentionActionFactory<JetFunctionOrPropertyAccessor> addFunctionBodyFactory = AddFunctionBodyFix.createFactory();
add(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addAbstractModifierFactory);
add(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addFunctionBodyFactory);
add(Errors.NON_MEMBER_ABSTRACT_FUNCTION, removeAbstractModifierFactory);
add(Errors.NON_MEMBER_ABSTRACT_ACCESSOR, removeAbstractModifierFactory);
add(Errors.NON_MEMBER_FUNCTION_NO_BODY, addFunctionBodyFactory);
add(Errors.NOTHING_TO_OVERRIDE, RemoveModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD));
add(Errors.VIRTUAL_METHOD_HIDDEN, AddModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD));
add(Errors.VAL_WITH_SETTER, ChangeVariableMutabilityFix.createFactory());
add(Errors.USELESS_CAST_STATIC_ASSERT_IS_FINE, ReplaceOperationInBinaryExpressionFix.createChangeCastToStaticAssertFactory());
add(Errors.USELESS_CAST, RemoveRightPartOfBinaryExpressionFix.createRemoveCastFactory());
IntentionActionFactory<JetPropertyAccessor> changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory();
add(Errors.WRONG_SETTER_PARAMETER_TYPE, changeAccessorTypeFactory);
add(Errors.WRONG_GETTER_RETURN_TYPE, changeAccessorTypeFactory);
add(Errors.USELESS_ELVIS, RemoveRightPartOfBinaryExpressionFix.createRemoveElvisOperatorFactory());
add(Errors.UNNECESSARY_SAFE_CALL, ReplaceSafeCallToDotCall.createFactory());
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java
+64
View File
@@ -0,0 +1,64 @@
package org.jetbrains.jet.plugin.quickfix;
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.psi.PsiWhiteSpace;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
*/
public class RemoveFunctionBodyFix extends IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> {
public RemoveFunctionBodyFix(@NotNull JetFunctionOrPropertyAccessor element) {
super(element);
}
@NotNull
@Override
public String getText() {
return "Remove function body";
}
@NotNull
@Override
public String getFamilyName() {
return "Remove function body";
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return super.isAvailable(project, editor, file) &&
element.getBodyExpression() != null;
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
JetFunctionOrPropertyAccessor newElement = (JetFunctionOrPropertyAccessor) element.copy();
JetExpression bodyExpression = newElement.getBodyExpression();
if (bodyExpression != null) {
PsiElement prevSibling = bodyExpression.getPrevSibling();
if (prevSibling instanceof PsiWhiteSpace) {
((JetElement)newElement).deleteChildInternal(prevSibling.getNode());
}
((JetElement)newElement).deleteChildInternal(bodyExpression.getNode());
}
element.replace(newElement);
}
public static IntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
return new IntentionActionFactory<JetFunctionOrPropertyAccessor>() {
@Override
public IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetFunctionOrPropertyAccessor;
return new RemoveFunctionBodyFix((JetFunctionOrPropertyAccessor) diagnostic.getPsiElement());
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
+31 -5
View File
@@ -5,13 +5,16 @@ 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.psi.PsiWhiteSpace;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetElement;
import org.jetbrains.jet.lang.psi.JetModifierList;
import org.jetbrains.jet.lang.psi.JetModifierListOwner;
import org.jetbrains.jet.lexer.JetKeywordToken;
import org.jetbrains.jet.lexer.JetToken;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
@@ -25,13 +28,21 @@ public class RemoveModifierFix extends ModifierFix {
@NotNull
@Override
public String getText() {
return "remove." + modifier.getValue() + ".modifier.fix";
if (modifier == JetTokens.ABSTRACT_KEYWORD) {
return "Make " + getElementName() + " not " + modifier.getValue();
}
return "Remove '" + modifier.getValue() + "' modifier";
}
@NotNull
@Override
public String getFamilyName() {
return "remove." + modifier.getValue() + "abstract.modifier.family";
return "Remove modifier";
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return element.isValid();
}
@Override
@@ -40,14 +51,29 @@ public class RemoveModifierFix extends ModifierFix {
}
@NotNull
private static JetModifierListOwner removeModifier(PsiElement element, JetToken modifier) {
JetModifierListOwner newElement = (JetModifierListOwner) (element.copy());
/*package*/ static <T extends JetModifierListOwner> T removeModifier(T element, JetToken modifier) {
T newElement = (T) (element.copy());
assert newElement.hasModifier(modifier);
ASTNode modifierNode = newElement.getModifierList().getModifierNode(modifier);
JetModifierList modifierList = newElement.getModifierList();
ASTNode modifierNode = modifierList.getModifierNode(modifier);
PsiElement whiteSpace = modifierNode.getPsi().getNextSibling();
((JetElement)newElement).deleteChildInternal(modifierNode);
if (modifierList.getChildren().length == 0) {
whiteSpace = modifierList.getNextSibling();
((JetElement) newElement).deleteChildInternal(modifierList.getNode());
removeWhiteSpace(newElement, whiteSpace);
}
else {
removeWhiteSpace(newElement, whiteSpace);
}
return newElement;
}
private static void removeWhiteSpace(PsiElement element, PsiElement subElement) {
if (subElement instanceof PsiWhiteSpace) {
((JetElement) element).deleteChildInternal(subElement.getNode());
}
}
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
return new IntentionActionFactory<JetModifierListOwner>() {
idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java
+121
View File
@@ -0,0 +1,121 @@
package org.jetbrains.jet.plugin.quickfix;
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 org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.types.JetType;
/**
* @author svtk
*/
public class RemovePartsFromPropertyFix extends IntentionActionForPsiElement<JetProperty> {
private final JetType type;
private final String partsToRemove;
private RemovePartsFromPropertyFix(@NotNull JetProperty element, JetType type) {
super(element);
this.type = type;
partsToRemove = partsToRemove(element.getGetter() != null && element.getGetter().getBodyExpression() != null,
element.getSetter() != null && element.getSetter().getBodyExpression() != null,
element.getInitializer() != null);
}
private static String partsToRemove(boolean hasGetter, boolean hasSetter, boolean hasInitializer) {
StringBuilder sb = new StringBuilder();
if (hasGetter) {
sb.append("getter");
if (hasSetter && hasInitializer) {
sb.append(", ");
}
else if (hasSetter || hasInitializer) {
sb.append(" and ");
}
}
if (hasSetter) {
sb.append("setter");
if (hasInitializer) {
sb.append(" and ");
}
}
if (hasInitializer) {
sb.append("initializer");
}
return sb.toString();
}
@NotNull
@Override
public String getText() {
return "Remove " + partsToRemove + " from property";
}
@NotNull
@Override
public String getFamilyName() {
return "Remove parts from property to make it abstract";
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return element.isValid();
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
JetProperty newElement = (JetProperty) element.copy();
JetPropertyAccessor getter = newElement.getGetter();
if (getter != null) {
newElement.deleteChildInternal(getter.getNode());
}
JetPropertyAccessor setter = newElement.getSetter();
if (setter != null) {
newElement.deleteChildInternal(setter.getNode());
}
JetExpression initializer = newElement.getInitializer();
if (initializer != null) {
PsiElement nameIdentifier = newElement.getNameIdentifier();
assert nameIdentifier != null;
PsiElement nextSibling = nameIdentifier.getNextSibling();
assert nextSibling != null;
newElement.deleteChildRange(nextSibling, initializer);
if (newElement.getPropertyTypeRef() == null) {
newElement = addPropertyType(project, newElement, type);
}
}
element.replace(newElement);
}
public static JetProperty addPropertyType(Project project, JetProperty property, JetType type) {
JetProperty newProperty = (JetProperty) property.copy();
JetTypeReference typeReference = JetPsiFactory.createType(project, type.toString());
PsiElement[] colon = JetPsiFactory.createColon(project);
PsiElement nameIdentifier = newProperty.getNameIdentifier();
assert nameIdentifier != null;
newProperty.addAfter(typeReference, nameIdentifier);
for (int i = colon.length - 1; i >= 0; i--) {
newProperty.addAfter(colon[i], nameIdentifier);
}
return newProperty;
}
public static IntentionActionFactory<JetProperty> createFactory() {
return new IntentionActionFactory<JetProperty>() {
@Override
public IntentionActionForPsiElement<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetProperty;
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
Object info = ((DiagnosticWithAdditionalInfo) diagnostic).getInfo();
assert info instanceof JetType;
return new RemovePartsFromPropertyFix((JetProperty) diagnostic.getPsiElement(), (JetType) info);
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java
+71
View File
@@ -0,0 +1,71 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetBinaryExpression;
import org.jetbrains.jet.lang.psi.JetBinaryExpressionWithTypeRHS;
import org.jetbrains.jet.lang.psi.JetExpression;
/**
* @author svtk
*/
public abstract class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> extends IntentionActionForPsiElement<T> {
public RemoveRightPartOfBinaryExpressionFix(@NotNull T element) {
super(element);
}
@NotNull
@Override
public String getFamilyName() {
return "Remove right part of a binary expression";
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
if (element instanceof JetBinaryExpression) {
JetBinaryExpression newElement = (JetBinaryExpression) element.copy();
element.replace(newElement.getLeft());
}
else if (element instanceof JetBinaryExpressionWithTypeRHS) {
JetBinaryExpressionWithTypeRHS newElement = (JetBinaryExpressionWithTypeRHS) element.copy();
element.replace(newElement.getLeft());
}
}
public static IntentionActionFactory<JetBinaryExpressionWithTypeRHS> createRemoveCastFactory() {
return new IntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
@Override
public IntentionActionForPsiElement<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetBinaryExpressionWithTypeRHS;
return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>((JetBinaryExpressionWithTypeRHS) diagnostic.getPsiElement()) {
@NotNull
@Override
public String getText() {
return "Remove cast";
}
};
}
};
}
public static IntentionActionFactory<JetBinaryExpression> createRemoveElvisOperatorFactory() {
return new IntentionActionFactory<JetBinaryExpression>() {
@Override
public IntentionActionForPsiElement<JetBinaryExpression> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetBinaryExpression;
return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpression>((JetBinaryExpression) diagnostic.getPsiElement()) {
@NotNull
@Override
public String getText() {
return "Remove elvis operator";
}
};
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java
+57
View File
@@ -0,0 +1,57 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetBinaryExpressionWithTypeRHS;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
/**
* @author svtk
*/
public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpression> extends IntentionActionForPsiElement<T> {
private final String expressionWithNecessaryOperation;
public ReplaceOperationInBinaryExpressionFix(@NotNull T element, String expressionWithNecessaryOperation) {
super(element);
this.expressionWithNecessaryOperation = expressionWithNecessaryOperation;
}
@NotNull
@Override
public String getFamilyName() {
return "Replace operation in a binary expression";
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
if (element instanceof JetBinaryExpressionWithTypeRHS) {
JetBinaryExpressionWithTypeRHS expression = (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, expressionWithNecessaryOperation);
JetBinaryExpressionWithTypeRHS newElement = (JetBinaryExpressionWithTypeRHS) element.copy();
CodeEditUtil.replaceChild(newElement.getNode(), newElement.getOperationSign().getNode(), expression.getOperationSign().getNode());
element.replace(newElement);
}
}
public static IntentionActionFactory<JetBinaryExpressionWithTypeRHS> createChangeCastToStaticAssertFactory() {
return new IntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
@Override
public IntentionActionForPsiElement<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetBinaryExpressionWithTypeRHS;
return new ReplaceOperationInBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>((JetBinaryExpressionWithTypeRHS) diagnostic.getPsiElement(), "2 : Int") {
@NotNull
@Override
public String getText() {
return "Replace a cast with a static assert";
}
};
}
};
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallToDotCall.java
+62
View File
@@ -0,0 +1,62 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
/**
* @author svtk
*/
public class ReplaceSafeCallToDotCall extends IntentionActionForPsiElement<JetElement> {
public ReplaceSafeCallToDotCall(@NotNull JetElement element) {
super(element);
}
@NotNull
@Override
public String getText() {
return "Replace to dot call";
}
@NotNull
@Override
public String getFamilyName() {
return "Replace safe call to dot call";
}
@Override
public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
if (element instanceof JetSafeQualifiedExpression) {
JetSafeQualifiedExpression safeQualifiedExpression = (JetSafeQualifiedExpression) element;
JetDotQualifiedExpression newElement = (JetDotQualifiedExpression) JetPsiFactory.createExpression(project, "x.foo");
CodeEditUtil.replaceChild(newElement.getNode(), newElement.getSelectorExpression().getNode(), safeQualifiedExpression.getSelectorExpression().getNode());
CodeEditUtil.replaceChild(newElement.getNode(), newElement.getReceiverExpression().getNode(), safeQualifiedExpression.getReceiverExpression().getNode());
element.replace(newElement);
}
else if (element instanceof JetWhenConditionCall) {
JetWhenConditionCall newElement = (JetWhenConditionCall) element;
JetDotQualifiedExpression callExpression = (JetDotQualifiedExpression) JetPsiFactory.createExpression(project, "x.foo");
CodeEditUtil.replaceChild(newElement.getNode(), newElement.getOperationTokenNode(), callExpression.getOperationTokenNode());
element.replace(newElement);
}
}
public static IntentionActionFactory<JetElement> createFactory() {
return new IntentionActionFactory<JetElement>() {
@Override
public IntentionActionForPsiElement<JetElement> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetElement;
return new ReplaceSafeCallToDotCall((JetElement) diagnostic.getPsiElement());
}
};
}
}
idea/testData/quickfix/abstract/afterAbstractFunctionInNonAbstractClass.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' not abstract" "true"
class A() {
<caret>fun foo()
}
idea/testData/quickfix/abstract/afterAbstractFunctionWithBody.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove function body" "true"
abstract class A() {
<caret>abstract fun foo()
}
idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass1.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'A' abstract" "true"
abstract class A() {
<caret>abstract var i : Int
}
idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass2.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'i' not abstract" "true"
class A() {
<caret>var i : Int
}
idea/testData/quickfix/abstract/afterAbstractPropertyInPrimaryConstructorParameters.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'i' not abstract" "true"
class A(<caret>val i: Int) {}
idea/testData/quickfix/abstract/afterAbstractPropertyNotInClass.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'i' not abstract" "true"
<caret>val i: Int = 1
idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer2.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove initializer from property" "true"
abstract class A {
abstract var i : Int<caret>
}
idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer3.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove initializer from property" "true"
abstract class A {
abstract var i : Int<caret>
}
idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter1.kt
+5
View File
@@ -0,0 +1,5 @@
// "Make 'i' not abstract" "true"
class B {
<caret>val i: Int
get() = $i
}
idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter2.kt
+5
View File
@@ -0,0 +1,5 @@
// "Remove getter and initializer from property" "true"
abstract class B {
abstract val i : <caret>Int
}
idea/testData/quickfix/abstract/afterAbstractPropertyWithInitializer1.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'i' not abstract" "true"
class A {
<caret>var i = 0
}
idea/testData/quickfix/abstract/afterAbstractPropertyWithSetter.kt
+5
View File
@@ -0,0 +1,5 @@
// "Make 'j' not abstract" "true"
class B {
<caret>var j: Int
set(v: Int) {}
}
idea/testData/quickfix/abstract/afterMustBeInitializedOrBeAbstract.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'i' abstract" "true"
abstract class A() {
abstract var <caret>i : Int
}
idea/testData/quickfix/abstract/afterNonAbstractFunctionWithNoBody.kt
+4
View File
@@ -0,0 +1,4 @@
// "Add function body" "true"
class A() {
fun <caret>foo() {}
}
idea/testData/quickfix/abstract/afterNonMemberAbstractAccessor.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'abstract get' not abstract" "true"
val i : Int = 0; <caret>get
idea/testData/quickfix/abstract/afterNonMemberAbstractFunction.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'foo' not abstract" "true"
<caret>fun foo()
idea/testData/quickfix/abstract/afterNonMemberFunctionNoBody.kt
+4
View File
@@ -0,0 +1,4 @@
// "Add function body" "true"
namespace a {
fun <caret>foo() {}
}
idea/testData/quickfix/abstract/afterRedundantAbstract.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' not abstract" "true"
trait A {
<caret>fun foo()
}
idea/testData/quickfix/abstract/afterReplaceOpen.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' abstract" "true"
abstract class B() {
abstract fun <caret>foo()
}
idea/testData/quickfix/abstract/beforeAbstractFunctionInNonAbstractClass.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' not abstract" "true"
class A() {
<caret>abstract fun foo()
}
idea/testData/quickfix/abstract/beforeAbstractFunctionWithBody.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove function body" "true"
abstract class A() {
<caret>abstract fun foo() {}
}
idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass1.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'A' abstract" "true"
class A() {
<caret>abstract var i : Int
}
idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass2.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'i' not abstract" "true"
class A() {
<caret>abstract var i : Int
}
idea/testData/quickfix/abstract/beforeAbstractPropertyInPrimaryConstructorParameters.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'i' not abstract" "true"
class A(<caret>abstract val i: Int) {}
idea/testData/quickfix/abstract/beforeAbstractPropertyNotInClass.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'i' not abstract" "true"
<caret>abstract val i: Int = 1
idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer2.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove initializer from property" "true"
abstract class A {
abstract var i = 0<caret>
}
idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer3.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove initializer from property" "true"
abstract class A {
abstract var i : Int = 0<caret>
}
idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter1.kt
+5
View File
@@ -0,0 +1,5 @@
// "Make 'i' not abstract" "true"
class B {
<caret>abstract val i: Int
get() = $i
}
idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter2.kt
+5
View File
@@ -0,0 +1,5 @@
// "Remove getter and initializer from property" "true"
abstract class B {
abstract val i = <caret>0
get() = $i
}
idea/testData/quickfix/abstract/beforeAbstractPropertyWithInitializer1.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'i' not abstract" "true"
class A {
<caret>abstract var i = 0
}
idea/testData/quickfix/abstract/beforeAbstractPropertyWithSetter.kt
+5
View File
@@ -0,0 +1,5 @@
// "Make 'j' not abstract" "true"
class B {
abstract<caret> var j: Int
set(v: Int) {}
}
idea/testData/quickfix/abstract/beforeHasFinal.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' abstract" "false"
class B() {
final fun <caret>foo()
}
idea/testData/quickfix/abstract/beforeMustBeInitializedOrBeAbstract.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'i' abstract" "true"
abstract class A() {
var <caret>i : Int
}
idea/testData/quickfix/abstract/beforeNonAbstractFunctionWithNoBody.kt
+4
View File
@@ -0,0 +1,4 @@
// "Add function body" "true"
class A() {
fun <caret>foo()
}
idea/testData/quickfix/abstract/beforeNonMemberAbstractAccessor.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'abstract get' not abstract" "true"
val i : Int = 0; <caret>abstract get
idea/testData/quickfix/abstract/beforeNonMemberAbstractFunction.kt
+2
View File
@@ -0,0 +1,2 @@
// "Make 'foo' not abstract" "true"
<caret>abstract fun foo()
idea/testData/quickfix/abstract/beforeNonMemberFunctionNoBody.kt
+4
View File
@@ -0,0 +1,4 @@
// "Add function body" "true"
namespace a {
fun <caret>foo()
}
idea/testData/quickfix/abstract/beforeRedundantAbstract.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' not abstract" "true"
trait A {
<caret>abstract fun foo()
}
idea/testData/quickfix/abstract/beforeReplaceOpen.kt
+4
View File
@@ -0,0 +1,4 @@
// "Make 'foo' abstract" "true"
abstract class B() {
open fun <caret>foo()
}
idea/testData/quickfix/changeVariableMutability/afterValWithSetter.kt
+5
View File
@@ -0,0 +1,5 @@
// "Make variable mutable" "true"
class A() {
var a: Int = 0
<caret>set(v: Int) {}
}
idea/testData/quickfix/changeVariableMutability/beforeValWithSetter.kt
+5
View File
@@ -0,0 +1,5 @@
// "Make variable mutable" "true"
class A() {
val a: Int = 0
<caret>set(v: Int) {}
}
idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt
+4
View File
@@ -0,0 +1,4 @@
// "Replace to dot call" "true"
fun foo(a: Any) {
<caret>a.equals(0)
}
idea/testData/quickfix/expressions/afterUnnecessarySafeCall2.kt
+7
View File
@@ -0,0 +1,7 @@
// "Replace to dot call" "true"
fun foo(a: Any) {
when (a) {
.equals(0) => true
else => false
}
}
idea/testData/quickfix/expressions/afterUselessCast.kt
+4
View File
@@ -0,0 +1,4 @@
// "Replace a cast with a static assert" "true"
fun foo(a: String) {
val b = a : Any
}
idea/testData/quickfix/expressions/afterUselessCastStaticAssertIsFine.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove cast" "true"
fun foo(a: Any) {
val b = a<caret>
}
idea/testData/quickfix/expressions/afterUselessElvis.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove elvis operator" "true"
fun foo(a: String) {
val b : String = <caret>a
}
idea/testData/quickfix/expressions/beforeUnnecessarySafeCall1.kt
+4
View File
@@ -0,0 +1,4 @@
// "Replace to dot call" "true"
fun foo(a: Any) {
a<caret>?.equals(0)
}
idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt
+7
View File
@@ -0,0 +1,7 @@
// "Replace to dot call" "true"
fun foo(a: Any) {
when (a) {
<caret>?.equals(0) => true
else => false
}
}
idea/testData/quickfix/expressions/beforeUselessCast.kt
+4
View File
@@ -0,0 +1,4 @@
// "Replace a cast with a static assert" "true"
fun foo(a: String) {
val b = a <caret>as Any
}
idea/testData/quickfix/expressions/beforeUselessCastStaticAssertIsFine.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove cast" "true"
fun foo(a: Any) {
val b = a <caret>as Any
}
idea/testData/quickfix/expressions/beforeUselessElvis.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove elvis operator" "true"
fun foo(a: String) {
val b : String = <caret>a ?: "s"
}
idea/testData/quickfix/override/afterNothingToOverride.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove 'override' modifier" "true"
class A() {
<caret>fun foo() {}
}
idea/testData/quickfix/override/afterVirtualMethodHidden.kt
+8
View File
@@ -0,0 +1,8 @@
// "Add 'override' modifier" "true"
open class A() {
fun foo() {}
}
class B() : A() {
override fun <caret>foo() {}
}
idea/testData/quickfix/override/beforeNothingToOverride.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove 'override' modifier" "true"
class A() {
<caret>override fun foo() {}
}
idea/testData/quickfix/override/beforeVirtualMethodHidden.kt
+8
View File
@@ -0,0 +1,8 @@
// "Add 'override' modifier" "true"
open class A() {
fun foo() {}
}
class B() : A() {
fun <caret>foo() {}
}
idea/testData/quickfix/typeAddition/afterWrongGetterParameterType.kt
+5
View File
@@ -0,0 +1,5 @@
// "Change getter type to Int" "true"
class A() {
val i: Int
get(): Int = 1
}
idea/testData/quickfix/typeAddition/afterWrongSetterParameterType.kt
+5
View File
@@ -0,0 +1,5 @@
// "Change setter parameter type to Int" "true"
class A() {
var i: Int = 0
set(v: Int) {}
}
idea/testData/quickfix/typeAddition/beforeWrongGetterParameterType.kt
+5
View File
@@ -0,0 +1,5 @@
// "Change getter type to Int" "true"
class A() {
val i: Int
get(): <caret>Any = 1
}
idea/testData/quickfix/typeAddition/beforeWrongSetterParameterType.kt
+5
View File
@@ -0,0 +1,5 @@
// "Change setter parameter type to Int" "true"
class A() {
var i: Int = 0
set(v: <caret>Any) {}
}
idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierTest.java
+24
View File
@@ -0,0 +1,24 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
import org.jetbrains.jet.JetTestCaseBase;
/**
* @author svtk
*/
public class AbstractModifierTest extends LightQuickFixTestCase {
public void test() throws Exception {
doAllTests();
}
@Override
protected String getBasePath() {
return "/quickfix/abstract";
}
@Override
protected String getTestDataPath() {
return JetTestCaseBase.getTestDataPathBase();
}
}
idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityTest.java
+24
View File
@@ -0,0 +1,24 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
import org.jetbrains.jet.JetTestCaseBase;
/**
* @author svtk
*/
public class ChangeVariableMutabilityTest extends LightQuickFixTestCase {
public void test() throws Exception {
doAllTests();
}
@Override
protected String getBasePath() {
return "/quickfix/changeVariableMutability";
}
@Override
protected String getTestDataPath() {
return JetTestCaseBase.getTestDataPathBase();
}
}
idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsTest.java
+24
View File
@@ -0,0 +1,24 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
import org.jetbrains.jet.JetTestCaseBase;
/**
* @author svtk
*/
public class ExpressionsTest extends LightQuickFixTestCase {
public void test() throws Exception {
doAllTests();
}
@Override
protected String getBasePath() {
return "/quickfix/expressions";
}
@Override
protected String getTestDataPath() {
return JetTestCaseBase.getTestDataPathBase();
}
}
idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierTest.java
+25
View File
@@ -0,0 +1,25 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
import org.jetbrains.jet.JetTestCaseBase;
/**
* @author svtk
*/
public class OverrideModifierTest extends LightQuickFixTestCase {
public void test() throws Exception {
doAllTests();
}
@Override
protected String getBasePath() {
return "/quickfix/override";
}
@Override
protected String getTestDataPath() {
return JetTestCaseBase.getTestDataPathBase();
}
}
idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionTests.java
+25
View File
@@ -0,0 +1,25 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
import org.jetbrains.jet.JetTestCaseBase;
/**
* @author svtk
*/
public class TypeAdditionTests extends LightQuickFixTestCase {
public void test() throws Exception {
doAllTests();
}
@Override
protected String getBasePath() {
return "/quickfix/typeAddition";
}
@Override
protected String getTestDataPath() {
return JetTestCaseBase.getTestDataPathBase();
}
}