diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
index cea0652b147..61474c536bf 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.lang.reflect.Field;
@@ -105,9 +106,9 @@ public interface Errors {
 
     // Modifiers
 
-    DiagnosticFactory1<PsiElement, Collection<JetKeywordToken>> INCOMPATIBLE_MODIFIERS = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetKeywordToken> ILLEGAL_MODIFIER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<PsiElement, JetKeywordToken, JetKeywordToken> REDUNDANT_MODIFIER = DiagnosticFactory2.create(Severity.WARNING);
+    DiagnosticFactory1<PsiElement, Collection<JetModifierKeywordToken>> INCOMPATIBLE_MODIFIERS = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, JetModifierKeywordToken> ILLEGAL_MODIFIER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> REDUNDANT_MODIFIER = DiagnosticFactory2.create(Severity.WARNING);
 
     // Annotations
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
index 339eb4aac4d..5d4bf223d55 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
@@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Arrays;
@@ -258,10 +259,10 @@ public class PositioningStrategies {
         @NotNull
         @Override
         public List<TextRange> mark(@NotNull JetModifierListOwner element) {
-            List<JetKeywordToken> visibilityTokens = Lists.newArrayList(
+            List<JetModifierKeywordToken> visibilityTokens = Lists.newArrayList(
                     JetTokens.PRIVATE_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PUBLIC_KEYWORD, JetTokens.INTERNAL_KEYWORD);
             List<TextRange> result = Lists.newArrayList();
-            for (JetKeywordToken token : visibilityTokens) {
+            for (JetModifierKeywordToken token : visibilityTokens) {
                 if (element.hasModifier(token)) {
                     //noinspection ConstantConditions
                     result.add(element.getModifierList().getModifierNode(token).getTextRange());
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java
index a98f2dd008d..d1433a00b20 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.psi.JetTypeConstraint;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 import org.jetbrains.jet.renderer.Renderer;
 
@@ -58,10 +59,10 @@ public class DefaultErrorMessages {
         MAP.put(NAME_SHADOWING, "Name shadowed: {0}", NAME);
 
         MAP.put(TYPE_MISMATCH, "Type mismatch: inferred type is {1} but {0} was expected", RENDER_TYPE, RENDER_TYPE);
-        MAP.put(INCOMPATIBLE_MODIFIERS, "Incompatible modifiers: ''{0}''", new Renderer<Collection<JetKeywordToken>>() {
+        MAP.put(INCOMPATIBLE_MODIFIERS, "Incompatible modifiers: ''{0}''", new Renderer<Collection<JetModifierKeywordToken>>() {
             @NotNull
             @Override
-            public String render(@NotNull Collection<JetKeywordToken> tokens) {
+            public String render(@NotNull Collection<JetModifierKeywordToken> tokens) {
                 StringBuilder sb = new StringBuilder();
                 for (JetKeywordToken token : tokens) {
                     if (sb.length() != 0) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationImpl.java
index cc6e6a5def4..de7345695c2 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationImpl.java
@@ -20,7 +20,7 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 
 import java.util.Collections;
 import java.util.List;
@@ -37,7 +37,7 @@ abstract class JetDeclarationImpl extends JetExpressionImpl implements JetDeclar
     }
 
     @Override
-    public boolean hasModifier(JetToken modifier) {
+    public boolean hasModifier(JetModifierKeywordToken modifier) {
         JetModifierList modifierList = getModifierList();
         return modifierList != null && modifierList.hasModifier(modifier);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationStub.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationStub.java
index c73dd0ae466..dc3e054d3db 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationStub.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationStub.java
@@ -22,7 +22,7 @@ import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 
 import java.util.Collections;
 import java.util.List;
@@ -43,7 +43,7 @@ abstract class JetDeclarationStub<T extends StubElement> extends JetElementImplS
     }
 
     @Override
-    public boolean hasModifier(JetToken modifier) {
+    public boolean hasModifier(JetModifierKeywordToken modifier) {
         JetModifierList modifierList = getModifierList();
         return modifierList != null && modifierList.hasModifier(modifier);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java
index 7cba39871b8..68b81346d07 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetToken;
 
 import java.util.ArrayList;
@@ -61,7 +62,7 @@ public class JetModifierList extends JetElementImpl {
 
         ASTNode node = getNode().getFirstChildNode();
         while (node != null) {
-            if (node.getElementType() instanceof JetKeywordToken) {
+            if (node.getElementType() instanceof JetModifierKeywordToken) {
                 modifierNodes.add(node);
             }
             node = node.getTreeNext();
@@ -69,12 +70,12 @@ public class JetModifierList extends JetElementImpl {
         return modifierNodes;
     }
 
-    public boolean hasModifier(JetToken token) {
+    public boolean hasModifier(JetModifierKeywordToken token) {
         return getModifierNode(token) != null;
     }
 
     @Nullable
-    public PsiElement getModifier(JetToken token) {
+    public PsiElement getModifier(JetModifierKeywordToken token) {
         return findChildByType(token);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java
index 2005cbd9aea..0aaf9bf8c5b 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java
@@ -18,11 +18,11 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 
 public interface JetModifierListOwner extends PsiElement, JetAnnotated {
     @Nullable
     JetModifierList getModifierList();
 
-    boolean hasModifier(JetToken modifier);
+    boolean hasModifier(JetModifierKeywordToken modifier);
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
index 1d51cd19837..b58f2a993f0 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
@@ -27,8 +27,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.psi.stubs.PsiJetObjectStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
@@ -98,7 +97,7 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
     }
 
     @Override
-    public boolean hasModifier(JetToken modifier) {
+    public boolean hasModifier(JetModifierKeywordToken modifier) {
         JetModifierList modifierList = getModifierList();
         return modifierList != null && modifierList.hasModifier(modifier);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java
index 068d68cb268..c9689d661bc 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
@@ -38,7 +38,7 @@ public class JetTypeProjection extends JetElementImpl implements JetModifierList
     }
 
     @Override
-    public boolean hasModifier(JetToken modifier) {
+    public boolean hasModifier(JetModifierKeywordToken modifier) {
         JetModifierList modifierList = getModifierList();
         return modifierList != null && modifierList.hasModifier(modifier);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
index 3dbe7e204db..530702060a3 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,6 +37,7 @@ import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.expressions.DataFlowUtils;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.Box;
 import org.jetbrains.jet.util.ReenteringLazyValueComputationException;
@@ -372,7 +373,7 @@ public class BodyResolver {
         annotationResolver.resolveAnnotationsWithArguments(scope, modifierList, trace);
 
         for (ASTNode node : modifierList.getModifierNodes()) {
-            trace.report(ILLEGAL_MODIFIER.on(node.getPsi(), (JetKeywordToken) node.getElementType()));
+            trace.report(ILLEGAL_MODIFIER.on(node.getPsi(), (JetModifierKeywordToken) node.getElementType()));
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
index b461367017f..ca70eedde71 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import javax.inject.Inject;
@@ -133,7 +134,7 @@ public class DeclarationsChecker {
         }
 
         for (ASTNode node : modifierList.getModifierNodes()) {
-            trace.report(ILLEGAL_MODIFIER.on(node.getPsi(), (JetKeywordToken) node.getElementType()));
+            trace.report(ILLEGAL_MODIFIER.on(node.getPsi(), (JetModifierKeywordToken) node.getElementType()));
         }
     }
 
@@ -505,7 +506,7 @@ public class DeclarationsChecker {
         PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter();
         JetModifierList getterModifierList = getter != null ? getter.getModifierList() : null;
         if (getterModifierList != null && getterDescriptor != null) {
-            Map<JetKeywordToken, ASTNode> nodes = ModifiersChecker.getNodesCorrespondingToModifiers(getterModifierList, Sets
+            Map<JetModifierKeywordToken, ASTNode> nodes = ModifiersChecker.getNodesCorrespondingToModifiers(getterModifierList, Sets
                     .newHashSet(JetTokens.PUBLIC_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PRIVATE_KEYWORD,
                                 JetTokens.INTERNAL_KEYWORD));
             if (getterDescriptor.getVisibility() != propertyDescriptor.getVisibility()) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
index 4eb73e176c7..ee2925ad10d 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -47,6 +47,7 @@ import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.storage.StorageManager;
 
@@ -1459,8 +1460,8 @@ public class DescriptorResolver {
             while (node != null) {
                 IElementType elementType = node.getElementType();
 
-                if (elementType != JetTokens.VARARG_KEYWORD && elementType instanceof JetKeywordToken) {
-                    trace.report(ILLEGAL_MODIFIER.on(node.getPsi(), (JetKeywordToken) elementType));
+                if (elementType != JetTokens.VARARG_KEYWORD && elementType instanceof JetModifierKeywordToken) {
+                    trace.report(ILLEGAL_MODIFIER.on(node.getPsi(), (JetModifierKeywordToken) elementType));
                 }
                 node = node.getTreeNext();
             }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java
index 9f71a1a98cb..2569290387b 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,8 +30,7 @@ import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetEnumEntry;
 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.JetModifierKeywordToken;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -40,10 +39,10 @@ import java.util.Map;
 import static org.jetbrains.jet.lexer.JetTokens.*;
 
 public class ModifiersChecker {
-    private static final Collection<JetKeywordToken> MODALITY_MODIFIERS =
+    private static final Collection<JetModifierKeywordToken> MODALITY_MODIFIERS =
             Lists.newArrayList(ABSTRACT_KEYWORD, OPEN_KEYWORD, FINAL_KEYWORD, OVERRIDE_KEYWORD);
 
-    private static final Collection<JetKeywordToken> VISIBILITY_MODIFIERS =
+    private static final Collection<JetModifierKeywordToken> VISIBILITY_MODIFIERS =
             Lists.newArrayList(PRIVATE_KEYWORD, PROTECTED_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD);
 
     @NotNull
@@ -82,7 +81,7 @@ public class ModifiersChecker {
         checkRedundantModifier(modifierList, Pair.create(OPEN_KEYWORD, ABSTRACT_KEYWORD), Pair.create(OPEN_KEYWORD, OVERRIDE_KEYWORD));
 
         checkCompatibility(modifierList, Lists.newArrayList(ABSTRACT_KEYWORD, OPEN_KEYWORD, FINAL_KEYWORD),
-                           Lists.<JetToken>newArrayList(ABSTRACT_KEYWORD, OPEN_KEYWORD));
+                           Lists.newArrayList(ABSTRACT_KEYWORD, OPEN_KEYWORD));
     }
 
     private void checkVisibilityModifiers(@Nullable JetModifierList modifierList, @NotNull DeclarationDescriptor descriptor) {
@@ -133,10 +132,10 @@ public class ModifiersChecker {
         return containingClass.isInner() || containingClass.getContainingDeclaration() instanceof FunctionDescriptor;
     }
 
-    private void checkCompatibility(@Nullable JetModifierList modifierList, Collection<JetKeywordToken> availableModifiers, Collection<JetToken>... availableCombinations) {
+    private void checkCompatibility(@Nullable JetModifierList modifierList, Collection<JetModifierKeywordToken> availableModifiers, Collection<JetModifierKeywordToken>... availableCombinations) {
         if (modifierList == null) return;
-        Collection<JetKeywordToken> presentModifiers = Sets.newLinkedHashSet();
-        for (JetKeywordToken modifier : availableModifiers) {
+        Collection<JetModifierKeywordToken> presentModifiers = Sets.newLinkedHashSet();
+        for (JetModifierKeywordToken modifier : availableModifiers) {
             if (modifierList.hasModifier(modifier)) {
                 presentModifiers.add(modifier);
             }
@@ -144,29 +143,29 @@ public class ModifiersChecker {
         if (presentModifiers.size() == 1) {
             return;
         }
-        for (Collection<JetToken> combination : availableCombinations) {
+        for (Collection<JetModifierKeywordToken> combination : availableCombinations) {
             if (presentModifiers.containsAll(combination) && combination.containsAll(presentModifiers)) {
                 return;
             }
         }
-        for (JetKeywordToken token : presentModifiers) {
+        for (JetModifierKeywordToken token : presentModifiers) {
             trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(modifierList.getModifierNode(token).getPsi(), presentModifiers));
         }
     }
 
-    private void checkRedundantModifier(@NotNull JetModifierList modifierList, Pair<JetKeywordToken, JetKeywordToken>... redundantBundles) {
-        for (Pair<JetKeywordToken, JetKeywordToken> tokenPair : redundantBundles) {
-            JetKeywordToken redundantModifier = tokenPair.getFirst();
-            JetKeywordToken sufficientModifier = tokenPair.getSecond();
+    private void checkRedundantModifier(@NotNull JetModifierList modifierList, Pair<JetModifierKeywordToken, JetModifierKeywordToken>... redundantBundles) {
+        for (Pair<JetModifierKeywordToken, JetModifierKeywordToken> tokenPair : redundantBundles) {
+            JetModifierKeywordToken redundantModifier = tokenPair.getFirst();
+            JetModifierKeywordToken sufficientModifier = tokenPair.getSecond();
             if (modifierList.hasModifier(redundantModifier) && modifierList.hasModifier(sufficientModifier)) {
                 trace.report(Errors.REDUNDANT_MODIFIER.on(modifierList.getModifierNode(redundantModifier).getPsi(), redundantModifier, sufficientModifier));
             }
         }
     }
 
-    public void checkIllegalInThisContextModifiers(@Nullable JetModifierList modifierList, @NotNull Collection<JetKeywordToken> illegalModifiers) {
+    public void checkIllegalInThisContextModifiers(@Nullable JetModifierList modifierList, @NotNull Collection<JetModifierKeywordToken> illegalModifiers) {
         if (modifierList == null) return;
-        for (JetKeywordToken modifier : illegalModifiers) {
+        for (JetModifierKeywordToken modifier : illegalModifiers) {
             if (modifierList.hasModifier(modifier)) {
                 trace.report(Errors.ILLEGAL_MODIFIER.on(modifierList.getModifierNode(modifier).getPsi(), modifier));
             }
@@ -174,9 +173,9 @@ public class ModifiersChecker {
     }
 
     @NotNull
-    public static Map<JetKeywordToken, ASTNode> getNodesCorrespondingToModifiers(@NotNull JetModifierList modifierList, @NotNull Collection<JetKeywordToken> possibleModifiers) {
-        Map<JetKeywordToken, ASTNode> nodes = Maps.newHashMap();
-        for (JetKeywordToken modifier : possibleModifiers) {
+    public static Map<JetModifierKeywordToken, ASTNode> getNodesCorrespondingToModifiers(@NotNull JetModifierList modifierList, @NotNull Collection<JetModifierKeywordToken> possibleModifiers) {
+        Map<JetModifierKeywordToken, ASTNode> nodes = Maps.newHashMap();
+        for (JetModifierKeywordToken modifier : possibleModifiers) {
             if (modifierList.hasModifier(modifier)) {
                 nodes.put(modifier, modifierList.getModifierNode(modifier));
             }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetKeywordToken.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetKeywordToken.java
index 6f54557d9b7..1ec9476d01b 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetKeywordToken.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetKeywordToken.java
@@ -41,7 +41,7 @@ public class JetKeywordToken extends JetSingleValueToken {
 
     private final boolean myIsSoft;
 
-    private JetKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
+    protected JetKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
         super(debugName, value);
         myIsSoft = isSoft;
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetModifierKeywordToken.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetModifierKeywordToken.java
new file mode 100644
index 00000000000..cfb41a75b48
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetModifierKeywordToken.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lexer;
+
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+
+
+/* Modifier keyword is a keyword that can be used in annotation position as part of modifier list.*/
+public final class JetModifierKeywordToken extends JetKeywordToken {
+
+    /**
+     * Generate keyword (identifier that has a keyword meaning in all possible contexts)
+     */
+    public static JetModifierKeywordToken keywordModifier(String value) {
+        return new JetModifierKeywordToken(value, value, false);
+    }
+
+    /**
+     * Generate soft keyword (identifier that has a keyword meaning only in some contexts)
+     */
+    public static JetModifierKeywordToken softKeywordModifier(String value) {
+        return new JetModifierKeywordToken(value, value, true);
+    }
+
+    private JetModifierKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
+        super(debugName, value, isSoft);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java
index 561c6e81ed3..2770657baf0 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java
@@ -60,7 +60,7 @@ public interface JetTokens {
     JetKeywordToken TRUE_KEYWORD             = JetKeywordToken.keyword("true");
     JetKeywordToken FALSE_KEYWORD            = JetKeywordToken.keyword("false");
     JetKeywordToken IS_KEYWORD               = JetKeywordToken.keyword("is");
-    JetKeywordToken IN_KEYWORD               = JetKeywordToken.keyword("in");
+    JetModifierKeywordToken IN_KEYWORD       = JetModifierKeywordToken.keywordModifier("in");
     JetKeywordToken THROW_KEYWORD            = JetKeywordToken.keyword("throw");
     JetKeywordToken RETURN_KEYWORD           = JetKeywordToken.keyword("return");
     JetKeywordToken BREAK_KEYWORD            = JetKeywordToken.keyword("break");
@@ -140,23 +140,23 @@ public interface JetTokens {
     JetKeywordToken BY_KEYWORD        = JetKeywordToken.softKeyword("by");
     JetKeywordToken GET_KEYWORD       = JetKeywordToken.softKeyword("get");
     JetKeywordToken SET_KEYWORD       = JetKeywordToken.softKeyword("set");
-    JetKeywordToken ABSTRACT_KEYWORD  = JetKeywordToken.softKeyword("abstract");
-    JetKeywordToken ENUM_KEYWORD      = JetKeywordToken.softKeyword("enum");
-    JetKeywordToken OPEN_KEYWORD      = JetKeywordToken.softKeyword("open");
-    JetKeywordToken INNER_KEYWORD     = JetKeywordToken.softKeyword("inner");
-    JetKeywordToken ANNOTATION_KEYWORD = JetKeywordToken.softKeyword("annotation");
-    JetKeywordToken OVERRIDE_KEYWORD  = JetKeywordToken.softKeyword("override");
-    JetKeywordToken PRIVATE_KEYWORD   = JetKeywordToken.softKeyword("private");
-    JetKeywordToken PUBLIC_KEYWORD    = JetKeywordToken.softKeyword("public");
-    JetKeywordToken INTERNAL_KEYWORD  = JetKeywordToken.softKeyword("internal");
-    JetKeywordToken PROTECTED_KEYWORD = JetKeywordToken.softKeyword("protected");
+    JetModifierKeywordToken ABSTRACT_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("abstract");
+    JetModifierKeywordToken ENUM_KEYWORD      = JetModifierKeywordToken.softKeywordModifier("enum");
+    JetModifierKeywordToken OPEN_KEYWORD      = JetModifierKeywordToken.softKeywordModifier("open");
+    JetModifierKeywordToken INNER_KEYWORD     = JetModifierKeywordToken.softKeywordModifier("inner");
+    JetModifierKeywordToken ANNOTATION_KEYWORD = JetModifierKeywordToken.softKeywordModifier("annotation");
+    JetModifierKeywordToken OVERRIDE_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("override");
+    JetModifierKeywordToken PRIVATE_KEYWORD   = JetModifierKeywordToken.softKeywordModifier("private");
+    JetModifierKeywordToken PUBLIC_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("public");
+    JetModifierKeywordToken INTERNAL_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("internal");
+    JetModifierKeywordToken PROTECTED_KEYWORD = JetModifierKeywordToken.softKeywordModifier("protected");
     JetKeywordToken CATCH_KEYWORD     = JetKeywordToken.softKeyword("catch");
-    JetKeywordToken OUT_KEYWORD       = JetKeywordToken.softKeyword("out");
-    JetKeywordToken VARARG_KEYWORD       = JetKeywordToken.softKeyword("vararg");
-    JetKeywordToken REIFIED_KEYWORD = JetKeywordToken.softKeyword("reified");
+    JetModifierKeywordToken OUT_KEYWORD       = JetModifierKeywordToken.softKeywordModifier("out");
+    JetModifierKeywordToken VARARG_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("vararg");
+    JetModifierKeywordToken REIFIED_KEYWORD   = JetModifierKeywordToken.softKeywordModifier("reified");
 
     JetKeywordToken FINALLY_KEYWORD   = JetKeywordToken.softKeyword("finally");
-    JetKeywordToken FINAL_KEYWORD   = JetKeywordToken.softKeyword("final");
+    JetModifierKeywordToken FINAL_KEYWORD     = JetModifierKeywordToken.softKeywordModifier("final");
 
     TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, CLASS_KEYWORD, TRAIT_KEYWORD,
                                         THIS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD,
@@ -173,10 +173,14 @@ public interface JetTokens {
                                              CATCH_KEYWORD, FINALLY_KEYWORD, OUT_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD
     );
 
-    TokenSet MODIFIER_KEYWORDS = TokenSet.create(ABSTRACT_KEYWORD, ENUM_KEYWORD,
-                                                 OPEN_KEYWORD, INNER_KEYWORD, ANNOTATION_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD,
-                                                 PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD
-    );
+    JetModifierKeywordToken[] MODIFIER_KEYWORDS_ARRAY =
+            new JetModifierKeywordToken[] {
+                    ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, ANNOTATION_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD,
+                    PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD,
+                    REIFIED_KEYWORD
+            };
+
+    TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY);
 
     TokenSet VISIBILITY_MODIFIERS = TokenSet.create(PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD);
 
diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java
index 48d76a0f3d7..f71235b46d9 100644
--- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java
+++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java
@@ -51,7 +51,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.plugin.JetLanguage;
 
 import javax.swing.*;
@@ -402,13 +402,13 @@ public class KotlinLightClassForExplicitDeclaration extends KotlinWrappingLightC
 
         // PUBLIC, PROTECTED, PRIVATE, ABSTRACT, FINAL
         //noinspection unchecked
-        List<Pair<JetKeywordToken, String>> jetTokenToPsiModifier = Lists.newArrayList(
+        List<Pair<JetModifierKeywordToken, String>> jetTokenToPsiModifier = Lists.newArrayList(
                 Pair.create(PUBLIC_KEYWORD, PsiModifier.PUBLIC),
                 Pair.create(INTERNAL_KEYWORD, PsiModifier.PUBLIC),
                 Pair.create(PROTECTED_KEYWORD, PsiModifier.PROTECTED),
                 Pair.create(FINAL_KEYWORD, PsiModifier.FINAL));
 
-        for (Pair<JetKeywordToken, String> tokenAndModifier : jetTokenToPsiModifier) {
+        for (Pair<JetModifierKeywordToken, String> tokenAndModifier : jetTokenToPsiModifier) {
             if (classOrObject.hasModifier(tokenAndModifier.first)) {
                 psiModifiers.add(tokenAndModifier.second);
             }
diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/declarations/ConvertMemberToExtension.java b/idea/src/org/jetbrains/jet/plugin/intentions/declarations/ConvertMemberToExtension.java
index 36d81e97900..476f0c3ebd0 100644
--- a/idea/src/org/jetbrains/jet/plugin/intentions/declarations/ConvertMemberToExtension.java
+++ b/idea/src/org/jetbrains/jet/plugin/intentions/declarations/ConvertMemberToExtension.java
@@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
@@ -148,7 +148,7 @@ public class ConvertMemberToExtension extends BaseIntentionAction {
         JetModifierList modifierList = member.getModifierList();
         if (modifierList == null) return "";
         for (IElementType modifierType : JetTokens.VISIBILITY_MODIFIERS.getTypes()) {
-            PsiElement modifier = modifierList.getModifier((JetToken) modifierType);
+            PsiElement modifier = modifierList.getModifier((JetModifierKeywordToken) modifierType);
             if (modifier != null) {
                 return modifierType == JetTokens.PROTECTED_KEYWORD ? "" : modifier.getText() + " ";
             }
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
index 5b34313f954..c11b2a8415b 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
@@ -27,7 +27,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lexer.JetKeywordToken;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetBundle;
 
@@ -38,9 +38,9 @@ import static org.jetbrains.jet.lexer.JetTokens.*;
 
 public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
     private final JetKeywordToken modifier;
-    private final JetToken[] modifiersThanCanBeReplaced;
+    private final JetModifierKeywordToken[] modifiersThanCanBeReplaced;
 
-    private AddModifierFix(@NotNull JetModifierListOwner element, @NotNull JetKeywordToken modifier, @Nullable JetToken[] modifiersThanCanBeReplaced) {
+    private AddModifierFix(@NotNull JetModifierListOwner element, @NotNull JetKeywordToken modifier, @Nullable JetModifierKeywordToken[] modifiersThanCanBeReplaced) {
         super(element);
         this.modifier = modifier;
         this.modifiersThanCanBeReplaced = modifiersThanCanBeReplaced;
@@ -85,7 +85,7 @@ public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
     }
 
     @NotNull
-    /*package*/ static JetModifierListOwner addModifier(@NotNull PsiElement element, @NotNull JetKeywordToken modifier, @Nullable JetToken[] modifiersThatCanBeReplaced, @NotNull Project project, boolean toBeginning) {
+    /*package*/ static JetModifierListOwner addModifier(@NotNull PsiElement element, @NotNull JetKeywordToken modifier, @Nullable JetModifierKeywordToken[] modifiersThatCanBeReplaced, @NotNull Project project, boolean toBeginning) {
         JetModifierListOwner newElement = (JetModifierListOwner) (element.copy());
         changeModifier(newElement, newElement.getModifierList(), newElement.getFirstChild(),
                        modifiersThatCanBeReplaced, project, toBeginning, JetPsiFactory.createModifierList(project, modifier));
@@ -94,7 +94,7 @@ public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
 
     public static void changeModifier(
             PsiElement element, @Nullable JetModifierList modifierList, @Nullable PsiElement insertAnchor,
-            JetToken[] modifiersThatCanBeReplaced, Project project, boolean toBeginning, JetModifierList listWithModifier
+            JetModifierKeywordToken[] modifiersThatCanBeReplaced, Project project, boolean toBeginning, JetModifierList listWithModifier
     ) {
         PsiElement whiteSpace = JetPsiFactory.createWhiteSpace(project);
         if (modifierList == null) {
@@ -116,7 +116,7 @@ public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
             if (modifiersThatCanBeReplaced != null) {
                 PsiElement toBeReplaced = null;
                 PsiElement toReplace = null;
-                for (JetToken modifierThatCanBeReplaced : modifiersThatCanBeReplaced) {
+                for (JetModifierKeywordToken modifierThatCanBeReplaced : modifiersThatCanBeReplaced) {
                     if (modifierList.hasModifier(modifierThatCanBeReplaced)) {
                         PsiElement modifierElement = modifierList.getModifierNode(modifierThatCanBeReplaced).getPsi();
                         assert modifierElement != null;
@@ -151,7 +151,7 @@ public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
     }
 
     @NotNull
-    /*package*/ static JetModifierListOwner addModifierWithDefaultReplacement(@NotNull PsiElement element, @NotNull JetKeywordToken modifier, @NotNull Project project, boolean toBeginning) {
+    /*package*/ static JetModifierListOwner addModifierWithDefaultReplacement(@NotNull PsiElement element, @NotNull JetModifierKeywordToken modifier, @NotNull Project project, boolean toBeginning) {
         return addModifier(element, modifier, MODIFIERS_THAT_CAN_BE_REPLACED.get(modifier), project, toBeginning);
     }
 
@@ -160,7 +160,7 @@ public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
         return true;
     }
 
-    public static <T extends JetModifierListOwner> JetSingleIntentionActionFactory createFactory(final JetKeywordToken modifier, final Class<T> modifierOwnerClass) {
+    public static <T extends JetModifierListOwner> JetSingleIntentionActionFactory createFactory(final JetModifierKeywordToken modifier, final Class<T> modifierOwnerClass) {
         return new JetSingleIntentionActionFactory() {
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
@@ -171,14 +171,14 @@ public class AddModifierFix extends JetIntentionAction<JetModifierListOwner> {
         };
     }
 
-    public static JetSingleIntentionActionFactory createFactory(JetKeywordToken modifier) {
+    public static JetSingleIntentionActionFactory createFactory(JetModifierKeywordToken modifier) {
         return createFactory(modifier, JetModifierListOwner.class);
     }
 
-    private static Map<JetToken, JetToken[]> MODIFIERS_THAT_CAN_BE_REPLACED = new HashMap<JetToken, JetToken[]>();
+    private static Map<JetModifierKeywordToken, JetModifierKeywordToken[]> MODIFIERS_THAT_CAN_BE_REPLACED = new HashMap<JetModifierKeywordToken, JetModifierKeywordToken[]>();
     static {
-        MODIFIERS_THAT_CAN_BE_REPLACED.put(ABSTRACT_KEYWORD, new JetToken[]{OPEN_KEYWORD, FINAL_KEYWORD});
-        MODIFIERS_THAT_CAN_BE_REPLACED.put(OVERRIDE_KEYWORD, new JetToken[]{OPEN_KEYWORD});
-        MODIFIERS_THAT_CAN_BE_REPLACED.put(OPEN_KEYWORD, new JetToken[]{FINAL_KEYWORD});
+        MODIFIERS_THAT_CAN_BE_REPLACED.put(ABSTRACT_KEYWORD, new JetModifierKeywordToken[]{OPEN_KEYWORD, FINAL_KEYWORD});
+        MODIFIERS_THAT_CAN_BE_REPLACED.put(OVERRIDE_KEYWORD, new JetModifierKeywordToken[]{OPEN_KEYWORD});
+        MODIFIERS_THAT_CAN_BE_REPLACED.put(OPEN_KEYWORD, new JetModifierKeywordToken[]{FINAL_KEYWORD});
     }
 }
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddOverrideToEqualsHashCodeToStringFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddOverrideToEqualsHashCodeToStringFix.java
index 91586ebb831..cd1b959f826 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddOverrideToEqualsHashCodeToStringFix.java
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddOverrideToEqualsHashCodeToStringFix.java
@@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetParameter;
 import org.jetbrains.jet.lang.psi.JetTypeReference;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.project.PluginJetFilesProvider;
 
@@ -40,7 +40,7 @@ import java.util.List;
 import static org.jetbrains.jet.lexer.JetTokens.*;
 
 public class AddOverrideToEqualsHashCodeToStringFix extends JetIntentionAction<PsiElement> {
-    private static final JetToken[] MODIFIERS_TO_REPLACE = {PUBLIC_KEYWORD, OPEN_KEYWORD};
+    private static final JetModifierKeywordToken[] MODIFIERS_TO_REPLACE = {PUBLIC_KEYWORD, OPEN_KEYWORD};
 
     public AddOverrideToEqualsHashCodeToStringFix(@NotNull PsiElement element) {
         super(element);
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java
index 647b456accc..2d31b4f9da5 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVisibilityModifierFix.java
@@ -32,14 +32,15 @@ import org.jetbrains.jet.lang.psi.JetModifierListOwner;
 import org.jetbrains.jet.lang.psi.JetParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.refactoring.JetRefactoringUtil;
 
 public class ChangeVisibilityModifierFix extends JetIntentionAction<JetModifierListOwner> {
-    public static final JetKeywordToken[] VISIBILITY_TOKENS =
-            new JetKeywordToken[] {JetTokens.PUBLIC_KEYWORD, JetTokens.PRIVATE_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.INTERNAL_KEYWORD};
+    public static final JetModifierKeywordToken[] VISIBILITY_TOKENS =
+            new JetModifierKeywordToken[] {JetTokens.PUBLIC_KEYWORD, JetTokens.PRIVATE_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.INTERNAL_KEYWORD};
 
     public ChangeVisibilityModifierFix(@NotNull JetModifierListOwner element) {
         super(element);
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
index ff1150a677e..1a3858f18e5 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
@@ -29,15 +29,15 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.Variance;
 import org.jetbrains.jet.lexer.JetKeywordToken;
-import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetBundle;
 
 public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner> {
-    private final JetKeywordToken modifier;
+    private final JetModifierKeywordToken modifier;
     private final boolean isRedundant;
 
-    public RemoveModifierFix(@NotNull JetModifierListOwner element, @NotNull JetKeywordToken modifier, boolean isRedundant) {
+    public RemoveModifierFix(@NotNull JetModifierListOwner element, @NotNull JetModifierKeywordToken modifier, boolean isRedundant) {
         super(element);
         this.modifier = modifier;
         this.isRedundant = isRedundant;
@@ -60,7 +60,7 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
     }
 
     @NotNull
-    private static <T extends JetModifierListOwner> T removeModifier(T element, JetToken modifier) {
+    private static <T extends JetModifierListOwner> T removeModifier(T element, JetModifierKeywordToken modifier) {
         JetModifierList modifierList = element.getModifierList();
         assert modifierList != null;
         removeModifierFromList(modifierList, modifier);
@@ -74,7 +74,7 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
     }
 
     @NotNull
-    private static JetModifierList removeModifierFromList(@NotNull JetModifierList modifierList, JetToken modifier) {
+    private static JetModifierList removeModifierFromList(@NotNull JetModifierList modifierList, JetModifierKeywordToken modifier) {
         assert modifierList.hasModifier(modifier);
         ASTNode modifierNode = modifierList.getModifierNode(modifier);
         PsiElement whiteSpace = modifierNode.getPsi().getNextSibling();
@@ -99,11 +99,11 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
     }
 
 
-    public static JetSingleIntentionActionFactory createRemoveModifierFromListOwnerFactory(JetKeywordToken modifier) {
+    public static JetSingleIntentionActionFactory createRemoveModifierFromListOwnerFactory(JetModifierKeywordToken modifier) {
         return createRemoveModifierFromListOwnerFactory(modifier, false);
     }
 
-    public static JetSingleIntentionActionFactory createRemoveModifierFromListOwnerFactory(final JetKeywordToken modifier, final boolean isRedundant) {
+    public static JetSingleIntentionActionFactory createRemoveModifierFromListOwnerFactory(final JetModifierKeywordToken modifier, final boolean isRedundant) {
         return new JetSingleIntentionActionFactory() {
             @Nullable
             @Override
@@ -128,8 +128,8 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
                 if (modifierListOwner == null) return null;
                 PsiElement psiElement = diagnostic.getPsiElement();
                 IElementType elementType = psiElement.getNode().getElementType();
-                if (!(elementType instanceof JetKeywordToken)) return null;
-                JetKeywordToken modifier = (JetKeywordToken) elementType;
+                if (!(elementType instanceof JetModifierKeywordToken)) return null;
+                JetModifierKeywordToken modifier = (JetModifierKeywordToken) elementType;
                 return new RemoveModifierFix(modifierListOwner, modifier, isRedundant);
             }
         };
@@ -145,8 +145,8 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
                 ASTNode projectionAstNode = projection.getProjectionNode();
                 if (projectionAstNode == null) return null;
                 IElementType elementType = projectionAstNode.getElementType();
-                if (!(elementType instanceof JetKeywordToken)) return null;
-                JetKeywordToken variance = (JetKeywordToken) elementType;
+                if (!(elementType instanceof JetModifierKeywordToken)) return null;
+                JetModifierKeywordToken variance = (JetModifierKeywordToken) elementType;
                 return new RemoveModifierFix(projection, variance, isRedundant);
             }
         };
@@ -163,7 +163,7 @@ public class RemoveModifierFix extends JetIntentionAction<JetModifierListOwner>
                 if (!(psiElement instanceof JetTypeParameter)) return null;
                 JetTypeParameter parameter = (JetTypeParameter) psiElement;
                 Variance variance = parameter.getVariance();
-                JetKeywordToken modifier;
+                JetModifierKeywordToken modifier;
                 switch (variance) {
                     case IN_VARIANCE:
                         modifier = JetTokens.IN_KEYWORD;