Little fix: 'redundant modifier in trait' instead of 'redundant abstract' error

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -100,7 +100,6 @@ public interface Errors {
     DiagnosticWithParameterFactory<JetProperty, JetType> PROPERTY_INITIALIZER_IN_TRAIT = DiagnosticWithParameterFactory.create(ERROR, "Property initializers are not allowed in traits", DiagnosticParameters.TYPE);
     SimpleDiagnosticFactory PROPERTY_INITIALIZER_NO_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR, "Initializer is not allowed here because this property has no backing field");
     DiagnosticWithParameterFactory<JetProperty, JetClass> PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR = DiagnosticWithParameterFactory.create(ERROR, "Property initializers are not allowed when no primary constructor is present", DiagnosticParameters.CLASS);
-    SimplePsiElementOnlyDiagnosticFactory<JetModifierListOwner> REDUNDANT_ABSTRACT = SimplePsiElementOnlyDiagnosticFactory.create(WARNING, "Abstract modifier is redundant in traits");
     PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, String, ClassDescriptor, JetClass> ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS = new PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, String, ClassDescriptor, JetClass>(ERROR, "Abstract property {0} in non-abstract class {1}") {
         @NotNull
         protected DiagnosticWithPsiElement<JetModifierListOwner> on(@NotNull JetModifierListOwner elementToBlame, @NotNull TextRange textRangeToMark, @NotNull String s, @NotNull ClassDescriptor classDescriptor, @NotNull JetClass aClass) {
@@ -122,7 +121,7 @@ public interface Errors {
     
     DiagnosticWithParameterFactory<JetNamedDeclaration, JetClass> NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticWithParameterFactory.create(ERROR, "Non final member in a final class", DiagnosticParameters.CLASS);
     DiagnosticWithParameterFactory<JetPropertyAccessor, JetProperty> NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY = DiagnosticWithParameterFactory.create(ERROR, "Non final accessor of a final property", DiagnosticParameters.PROPERTY);
-    DiagnosticWithParameterFactory<JetPropertyAccessor, JetProperty> ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY = DiagnosticWithParameterFactory.create(ERROR, "Abstract accessor of a non abstract property", DiagnosticParameters.PROPERTY);
+    DiagnosticWithParameterFactory<JetPropertyAccessor, JetProperty> ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY = DiagnosticWithParameterFactory.create(ERROR, "Abstract accessor of a final property", DiagnosticParameters.PROPERTY);
 
     SimpleDiagnosticFactory PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = SimpleDiagnosticFactory.create(ERROR, "Projections are not allowed on type arguments of functions and properties"); // TODO : better positioning
     SimpleDiagnosticFactory SUPERTYPE_NOT_INITIALIZED = SimpleDiagnosticFactory.create(ERROR, "This type has a constructor, and thus must be initialized here");

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory2.java

@@ -6,10 +6,18 @@ import com.intellij.psi.PsiElement;
  * @author svtk
  */
 public class PsiElementOnlyDiagnosticFactory2<T extends PsiElement, A, B> extends DiagnosticFactoryWithPsiElement2<T, A, B> implements PsiElementOnlyDiagnosticFactory<T> {
+    public static <T extends PsiElement, A, B> PsiElementOnlyDiagnosticFactory2<T, A, B> create(Severity severity, String messageStub, Renderer renderer) {
+        return new PsiElementOnlyDiagnosticFactory2<T, A, B>(severity, messageStub, renderer);
+    }
+
     public static <T extends PsiElement, A, B> PsiElementOnlyDiagnosticFactory2<T, A, B> create(Severity severity, String messageStub) {
         return new PsiElementOnlyDiagnosticFactory2<T, A, B>(severity, messageStub);
     }
 
+    public PsiElementOnlyDiagnosticFactory2(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
     protected PsiElementOnlyDiagnosticFactory2(Severity severity, String message) {
         super(severity, message);
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java

@@ -156,7 +156,7 @@ public class DeclarationsChecker {
                 return;
             }
             if (classDescriptor.getKind() == ClassKind.TRAIT) {
-                context.getTrace().report(REDUNDANT_ABSTRACT.on(property, abstractNode));
+                context.getTrace().report(REDUNDANT_MODIFIER_IN_TRAIT.on(modifierList, abstractNode, JetTokens.ABSTRACT_KEYWORD));
             }
         }
 
@@ -254,7 +254,7 @@ public class DeclarationsChecker {
                 context.getTrace().report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(functionOrPropertyAccessor, abstractNode, functionDescriptor.getName(), classDescriptor, (JetClass) classElement));
             }
             if (hasAbstractModifier && inTrait && !isPropertyAccessor) {
-                context.getTrace().report(REDUNDANT_ABSTRACT.on(functionOrPropertyAccessor, abstractNode));
+                context.getTrace().report(REDUNDANT_MODIFIER_IN_TRAIT.on(modifierList, abstractNode, JetTokens.ABSTRACT_KEYWORD));
             }
             if (function.getBodyExpression() != null && hasAbstractModifier) {
                 context.getTrace().report(ABSTRACT_FUNCTION_WITH_BODY.on(functionOrPropertyAccessor, abstractNode, functionDescriptor));
@@ -283,6 +283,7 @@ public class DeclarationsChecker {
                                                             ? propertyDescriptor.getGetter()
                                                             : propertyDescriptor.getSetter();
             checkFunction(accessor, accessorDescriptor);
+            checkModifiers(accessor.getModifierList());
             if (propertyDescriptor.getModality() == Modality.FINAL && accessor.hasModifier(JetTokens.OPEN_KEYWORD)) {
                 ASTNode openModifierNode = accessor.getModifierList().getModifierNode(JetTokens.OPEN_KEYWORD);
                 context.getTrace().report(NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY.on(accessor, openModifierNode, property));

idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java

@@ -40,11 +40,6 @@ public class AddModifierFix extends ModifierFix {
         return "Add modifier";
     }
 
-    @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 {
         element.replace(addModifier(element, modifier, modifiersThanCanBeReplaced, project));

idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java

@@ -1,6 +1,11 @@
 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.DiagnosticParameter;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
@@ -10,7 +15,8 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElementImpl;
  * @author svtk
  */
 public class QuickFixUtil {
-    private QuickFixUtil() {}
+    private QuickFixUtil() {
+    }
 
     public static <T extends PsiElement, P extends T> JetIntentionActionFactory<PsiElement> createFactoryRedirectingAdditionalInfoToAnotherFactory(final JetIntentionActionFactory<T> factory, final DiagnosticParameter<P> parameter) {
         return new JetIntentionActionFactory<PsiElement>() {
@@ -18,10 +24,49 @@ public class QuickFixUtil {
             public JetIntentionAction<PsiElement> createAction(DiagnosticWithPsiElement diagnostic) {
 
                 DiagnosticWithParameters<PsiElement> diagnosticWithParameters = JetIntentionAction.assertAndCastToDiagnosticWithParameters(diagnostic, parameter);
-                T element = diagnosticWithParameters.getParameter(parameter);
+                P element = diagnosticWithParameters.getParameter(parameter);
                 return (JetIntentionAction<PsiElement>) factory.createAction(new DiagnosticWithPsiElementImpl<T>(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), element));
             }
         };
     }
 
+    public static <T extends PsiElement, P extends T> JetIntentionActionFactory<PsiElement> createFactoryRedirectingAdditionalInfoIfAnyToAnotherFactory(final JetIntentionActionFactory<T> factory, final DiagnosticParameter<P> parameter) {
+        return new JetIntentionActionFactory<PsiElement>() {
+            @Override
+            public JetIntentionAction<PsiElement> createAction(DiagnosticWithPsiElement diagnostic) {
+
+                if (diagnostic instanceof DiagnosticWithParameters && ((DiagnosticWithParameters<PsiElement>) diagnostic).hasParameter(parameter)) {
+                    P element = ((DiagnosticWithParameters<PsiElement>) diagnostic).getParameter(parameter);
+                    return (JetIntentionAction<PsiElement>) factory.createAction(new DiagnosticWithPsiElementImpl<T>(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), element));
+                }
+                return createDoNothingAction(diagnostic);
+            }
+        };
+    }
+
+    public static JetIntentionAction<PsiElement> createDoNothingAction(DiagnosticWithPsiElement diagnostic) {
+        return new JetIntentionAction<PsiElement>(diagnostic.getPsiElement()) {
+            @Override
+            public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+                return false;
+            }
+
+            @NotNull
+            @Override
+            public String getText() {
+                throw new UnsupportedOperationException();
+            }
+
+            @NotNull
+            @Override
+            public String getFamilyName() {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
 }

idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java

@@ -48,7 +48,6 @@ public class QuickFixes {
         add(Errors.PROPERTY_INITIALIZER_IN_TRAIT, removePartsFromPropertyFactory);
 
         add(Errors.MUST_BE_INITIALIZED_OR_BE_ABSTRACT, addAbstractModifierFactory);
-        add(Errors.REDUNDANT_ABSTRACT, removeAbstractModifierFactory);
 
         JetIntentionActionFactory<PsiElement> addAbstractToClassFactory = QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addAbstractModifierFactory, DiagnosticParameters.CLASS);
         add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
@@ -70,7 +69,7 @@ public class QuickFixes {
         add(Errors.NON_MEMBER_FUNCTION_NO_BODY, addFunctionBodyFactory);
 
         add(Errors.NOTHING_TO_OVERRIDE, RemoveModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD));
-        add(Errors.VIRTUAL_MEMBER_HIDDEN, AddModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD));
+        add(Errors.VIRTUAL_MEMBER_HIDDEN, AddModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD, new JetToken[] {JetTokens.OPEN_KEYWORD}));
 
         add(Errors.VAL_WITH_SETTER, ChangeVariableMutabilityFix.createFactory());
 

idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java

@@ -41,11 +41,6 @@ public class RemoveModifierFix extends ModifierFix {
         return "Remove modifier";
     }
 
-    @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 {
         JetModifierListOwner newElement = (JetModifierListOwner) element.copy();

idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java

@@ -76,11 +76,6 @@ public class RemovePartsFromPropertyFix extends JetIntentionAction<JetProperty>
         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();

idea/testData/checkerWithErrorTypes/full/Abstract.jet

@@ -92,29 +92,29 @@ trait MyTrait {
     //properties
     val a: Int
     val a1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>1<!>
-    <!REDUNDANT_ABSTRACT!>abstract<!> val a2: Int
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a2: Int
-    <!REDUNDANT_ABSTRACT!>abstract<!> val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
 
     var b: Int                                                  private set
     var b1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;                             private set
-    <!REDUNDANT_ABSTRACT!>abstract<!> var b2: Int                     private set
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b2: Int                     private set
-    <!REDUNDANT_ABSTRACT!>abstract<!> var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
 
     var <!BACKING_FIELD_IN_TRAIT!>c<!>: Int                                   set(v: Int) { $c = v }
     var <!BACKING_FIELD_IN_TRAIT!>c1<!>: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;              set(v: Int) { $c1 = v }
-    <!REDUNDANT_ABSTRACT!>abstract<!> var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
-    <!REDUNDANT_ABSTRACT!>abstract<!> var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
 
     val e: Int                                                  get() = a
     val e1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;                             get() = a
-    <!REDUNDANT_ABSTRACT!>abstract<!> val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
-    <!REDUNDANT_ABSTRACT!>abstract<!> val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
 
     //methods
     fun f()
     fun g() {}
-    <!REDUNDANT_ABSTRACT!>abstract<!> fun h()
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> fun h()
-    <!REDUNDANT_ABSTRACT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
+    <!REDUNDANT_MODIFIER_IN_TRAIT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
 
     //property accessors
     var i: Int                       abstract get  abstract set

idea/testData/quickfix/abstract/afterRedundantAbstract.kt

@@ -1,4 +1,4 @@
-// "Make 'foo' not abstract" "true"
+// "Remove redundant 'abstract' modifier" "true"
 trait A {
     <caret>fun foo()
 }

idea/testData/quickfix/abstract/beforeRedundantAbstract.kt

@@ -1,4 +1,4 @@
-// "Make 'foo' not abstract" "true"
+// "Remove redundant 'abstract' modifier" "true"
 trait A {
     <caret>abstract fun foo()
 }