Added quick fixes binding to error codes

idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java

@@ -1,6 +1,8 @@
 package org.jetbrains.jet.plugin.annotations;
 
+import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.codeInspection.ProblemHighlightType;
+import com.intellij.lang.annotation.Annotation;
 import com.intellij.lang.annotation.AnnotationHolder;
 import com.intellij.lang.annotation.Annotator;
 import com.intellij.openapi.progress.ProcessCanceledException;
@@ -18,6 +20,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.plugin.AnalyzerFacade;
 import org.jetbrains.jet.plugin.JetHighlighter;
+import org.jetbrains.jet.plugin.quickfix.QuickFixes;
 
 import java.util.Collection;
 import java.util.HashSet;
@@ -49,6 +52,7 @@ public class JetPsiChecker implements Annotator {
                     Collection<Diagnostic> diagnostics = bindingContext.getDiagnostics();
                     Set<DeclarationDescriptor> redeclarations = new HashSet<DeclarationDescriptor>();
                     for (Diagnostic diagnostic : diagnostics) {
+                        Annotation annotation = null;
                         if (diagnostic.getSeverity() == Severity.ERROR) {
                             if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
                                 UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic) diagnostic;
@@ -70,11 +74,25 @@ public class JetPsiChecker implements Annotator {
                                 markRedeclaration(redeclarations, redeclarationDiagnostic.getB(), bindingContext, holder);
                             }
                             else {
-                                holder.createErrorAnnotation(diagnostic.getFactory().getTextRange(diagnostic), diagnostic.getMessage());
+                                annotation = holder.createErrorAnnotation(diagnostic.getFactory().getTextRange(diagnostic), diagnostic.getMessage());
                             }
                         }
                         else if (diagnostic.getSeverity() == Severity.WARNING) {
-                            holder.createWarningAnnotation(diagnostic.getFactory().getTextRange(diagnostic), diagnostic.getMessage());
+                            annotation = holder.createWarningAnnotation(diagnostic.getFactory().getTextRange(diagnostic), diagnostic.getMessage());
+                        }
+                        if (annotation != null && diagnostic instanceof DiagnosticWithPsiElement) {
+                            DiagnosticWithPsiElement diagnosticWithPsiElement = (DiagnosticWithPsiElement) diagnostic;
+                            if (diagnostic.getFactory() instanceof PsiElementOnlyDiagnosticFactory) {
+                                PsiElementOnlyDiagnosticFactory factory = (PsiElementOnlyDiagnosticFactory) diagnostic.getFactory();
+                                QuickFixes.IntentionActionFactory intentionActionFactory = QuickFixes.get(factory);
+                                IntentionAction action = null;
+                                if (intentionActionFactory != null) {
+                                    action = intentionActionFactory.createAction(diagnosticWithPsiElement);
+                                }
+                                if (action != null) {
+                                    annotation.registerFix(action);
+                                }
+                            }
                         }
                     }
                 }

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

@@ -0,0 +1,47 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.google.common.collect.Maps;
+import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.diagnostics.Errors;
+import org.jetbrains.jet.lang.diagnostics.PsiElementOnlyDiagnosticFactory;
+
+import java.util.Map;
+
+/**
+* @author svtk
+*/
+public class QuickFixes {
+    private static Map<PsiElementOnlyDiagnosticFactory, IntentionActionFactory> actionMap = Maps.newHashMap();
+
+    public static IntentionActionFactory get(PsiElementOnlyDiagnosticFactory f) {
+        return actionMap.get(f);
+    }
+
+    private QuickFixes() {}
+
+    public static abstract class IntentionActionForPsiElement<T extends PsiElement> implements IntentionAction {
+        protected T psiElement;
+
+        public IntentionActionForPsiElement(T element) {
+            this.psiElement = element;
+        }
+    }
+
+    public interface IntentionActionFactory<T extends PsiElement> {
+        IntentionActionForPsiElement createAction(DiagnosticWithPsiElement diagnostic);
+    }
+
+    private static <T extends PsiElement> void add(PsiElementOnlyDiagnosticFactory<T> diagnosticFactory, IntentionActionFactory<T> actionFactory) {
+        actionMap.put(diagnosticFactory, actionFactory);
+    }
+
+
+    static {
+        add(Errors.REDUNDANT_ABSTRACT, RemoveAbstractModifierFix.factory);
+    }
+}
+

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

@@ -0,0 +1,67 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.lang.ASTNode;
+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.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+* @author svtk
+*/
+public class RemoveAbstractModifierFix extends QuickFixes.IntentionActionForPsiElement<JetDeclaration> {
+    public RemoveAbstractModifierFix(JetDeclaration declaration) {
+        super(declaration);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "remove.abstract.modifier.fix";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "remove.abstract.modifier.family";
+    }
+
+    @Override
+    public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+        return psiElement.isValid();
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetDeclaration declaration = removeAbstractModifier(psiElement);
+        psiElement.replace(declaration);
+    }
+
+    public static JetDeclaration removeAbstractModifier(PsiElement element) {
+        assert element instanceof JetDeclaration;
+        JetDeclaration declaration = (JetDeclaration) (element.copy());
+        assert declaration.hasModifier(JetTokens.ABSTRACT_KEYWORD);
+        ASTNode abstractNode = declaration.getModifierList().getModifierNode(JetTokens.ABSTRACT_KEYWORD);
+        declaration.deleteChildInternal(abstractNode);
+        return declaration;
+    }
+
+    @Override
+    public boolean startInWriteAction() {
+        return true;
+    }
+
+    public static QuickFixes.IntentionActionFactory<JetDeclaration> factory =
+        new QuickFixes.IntentionActionFactory<JetDeclaration>() {
+            @Override
+            public QuickFixes.IntentionActionForPsiElement<JetDeclaration> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetDeclaration;
+                return new RemoveAbstractModifierFix((JetDeclaration) diagnostic.getPsiElement());
+            }
+        };
+}