Added QuickFix for redundant type projections.

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

@@ -102,6 +102,7 @@ public class QuickFixes {
         factories.put(ABSTRACT_MODIFIER_IN_TRAIT, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD, true));
         factories.put(OPEN_MODIFIER_IN_TRAIT, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD, true));
         factories.put(TRAIT_CAN_NOT_BE_FINAL, removeFinalModifierFactory);
+        factories.put(REDUNDANT_PROJECTION, RemoveModifierFix.createRemoveProjectionFactory());
 
         JetIntentionActionFactory removeOpenModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD);
         factories.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, AddModifierFix.createFactory(OPEN_KEYWORD, JetClass.class));

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

@@ -29,6 +29,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetModifierList;
 import org.jetbrains.jet.lang.psi.JetModifierListOwner;
+import org.jetbrains.jet.lang.psi.JetTypeProjection;
 import org.jetbrains.jet.lexer.JetKeywordToken;
 import org.jetbrains.jet.lexer.JetToken;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -135,4 +136,21 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
             }
         };
     }
+
+    public static JetIntentionActionFactory createRemoveProjectionFactory() {
+        return new JetIntentionActionFactory() {
+            @Nullable
+            @Override
+            public JetIntentionAction<JetModifierListOwner> createAction(Diagnostic diagnostic) {
+                JetTypeProjection projection = QuickFixUtil.getParentElementOfType(diagnostic, JetTypeProjection.class);
+                if (projection == null) return null;
+                ASTNode projectionAstNode = projection.getProjectionNode();
+                if (projectionAstNode == null) return null;
+                IElementType elementType = projectionAstNode.getElementType();
+                if (!(elementType instanceof JetKeywordToken)) return null;
+                JetKeywordToken variance = (JetKeywordToken) elementType;
+                return new RemoveModifierFix(projection, variance, true);
+            }
+        };
+    }
 }

idea/testData/quickfix/typeProjection/afterRemoveRedundantProjection1.kt

@@ -0,0 +1,8 @@
+// "Remove redundant 'out' modifier" "true"
+class Foo<out T> {
+    val x = 0
+}
+
+fun bar(x : Foo<Any>) {
+
+}

idea/testData/quickfix/typeProjection/afterRemoveRedundantProjection2.kt

@@ -0,0 +1,8 @@
+// "Remove redundant 'in' modifier" "true"
+class Foo<in T> {
+    val x = 0
+}
+
+fun bar(x : Foo<Any>) {
+
+}

idea/testData/quickfix/typeProjection/beforeRemoveRedundantProjection1.kt

@@ -0,0 +1,8 @@
+// "Remove redundant 'out' modifier" "true"
+class Foo<out T> {
+    val x = 0
+}
+
+fun bar(x : Foo< out<caret>  Any>) {
+
+}

idea/testData/quickfix/typeProjection/beforeRemoveRedundantProjection2.kt

@@ -0,0 +1,8 @@
+// "Remove redundant 'in' modifier" "true"
+class Foo<in T> {
+    val x = 0
+}
+
+fun bar(x : Foo< in<caret>  Any>) {
+
+}