Simple modifiers

idea/src/org/jetbrains/jet/JetNodeTypes.java

@@ -31,6 +31,7 @@ public interface JetNodeTypes {
     JetNodeType IMPORT_DIRECTIVE = new JetNodeType("IMPORT_DIRECTIVE");
     JetNodeType IMPORTED = new JetNodeType("IMPORTED");
     JetNodeType NAMESPACE_BODY = new JetNodeType("NAMESPACE_BODY");
+    JetNodeType MODIFIER_LIST = new JetNodeType("MODIFIER_LIST");
 
 
     IElementType NAMESPACE_NAME = new JetNodeType("NAMESPACE_NAME");

idea/src/org/jetbrains/jet/lang/parsing/JetParsing.java

@@ -8,16 +8,26 @@ import com.intellij.lang.WhitespaceSkippedCallback;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.jet.JetNodeType;
-import org.jetbrains.jet.lexer.JetSoftKeywordToken;
+import org.jetbrains.jet.lexer.JetKeywordToken;
 import org.jetbrains.jet.lexer.JetToken;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import static org.jetbrains.jet.JetNodeTypes.*;
 import static org.jetbrains.jet.lexer.JetTokens.*;
 
 public class JetParsing {
-    public static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.create(LT, WRAPS_KEYWORD, LPAR, COLON, LBRACE);
+    private static final Map<String, IElementType> MODIFIER_KEYWORD_MAP = new HashMap<String, IElementType>();
-    public static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, WRAPS_KEYWORD, LPAR, COLON, LBRACE, GT);
+    static {
-    public static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR);
+        for (IElementType softKeyword : MODIFIER_KEYWORDS.getTypes()) {
+            MODIFIER_KEYWORD_MAP.put(((JetKeywordToken) softKeyword).getValue(), softKeyword);
+        }
+    }
+
+    private static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.create(LT, WRAPS_KEYWORD, LPAR, COLON, LBRACE);
+    private static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, WRAPS_KEYWORD, LPAR, COLON, LBRACE, GT);
+    private static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR);
     private static final TokenSet NAMESPACE_NAME_RECOVERY_SET = TokenSet.create(DOT, EOL_OR_SEMICOLON);
 
     private final WhitespaceSkippedCallback myWhitespaceSkippedCallback = new WhitespaceSkippedCallback() {
@@ -163,11 +173,7 @@ public class JetParsing {
      */
     private void parseTopLevelObject() {
         PsiBuilder.Marker decl = mark();
-        if (!parseModifierList()) {
+        parseModifierList();
-            decl.drop();
-            advance(); // TODO
-            return;
-        }
 
         JetToken keywordToken = tt();
         JetNodeType declType = null;
@@ -199,9 +205,54 @@ public class JetParsing {
         }
     }
 
-    private boolean parseModifierList() {
+    /*
-        // TODO
+     * modifier
-        return true;
+     *   : "abstract"
+     *   : "virtual"
+     *   : "enum"
+     *   : "open"
+     *   : "attribute"
+     *   : "override"
+     *   : "virtual"
+     *   : "abstract"
+     *   : "private"
+     *   : "protected"
+     *   : "public"
+     *   : "internal"
+     *   : "in"
+     *   : "out"
+     *   : "lazy"
+     *   : "ref"
+     */
+    private boolean parseModifierSoftKeyword() {
+        if (!at(IDENTIFIER)) return false;
+        String tokenText = myBuilder.getTokenText();
+        IElementType tokenType = MODIFIER_KEYWORD_MAP.get(tokenText);
+        if (tokenType != null) {
+            myBuilder.remapCurrentToken(tokenType);
+            advance();
+            return true;
+        }
+        return false;
+    }
+
+    private void parseModifierList() {
+        PsiBuilder.Marker list = mark();
+        boolean empty = true;
+        while (true) {
+            if (MODIFIER_KEYWORDS.contains(tt())) {
+                advance();
+            }
+            else {
+                if (!parseModifierSoftKeyword()) break;
+            }
+            empty = false;
+        }
+        if (empty) {
+            list.drop();
+        } else {
+            list.done(MODIFIER_LIST);
+        }
     }
 
     /*
@@ -518,16 +569,9 @@ public class JetParsing {
             if (token == SEMICOLON) return true;
             if (myEOLInLastWhitespace) return true;
         }
-        if (token == IDENTIFIER && expectation instanceof JetSoftKeywordToken) {
+        if (token == IDENTIFIER && expectation instanceof JetKeywordToken) {
-            if (((JetSoftKeywordToken) expectation).getValue().equals(myBuilder.getTokenText())) {
+            JetKeywordToken expectedKeyword = (JetKeywordToken) expectation;
-//                myBuilder.setTokenTypeRemapper(new ITokenTypeRemapper() {
+            if (expectedKeyword.isSoft() && expectedKeyword.getValue().equals(myBuilder.getTokenText())) {
-//                    public IElementType filter(IElementType source, int start, int end, CharSequence text) {
-//                        return expectation;
-//                    }
-//                });
-
-//                tt();
-//                myBuilder.setTokenTypeRemapper(null);
                 myBuilder.remapCurrentToken(expectation);
                 return true;
             }

idea/src/org/jetbrains/jet/lexer/JetKeywordToken.java

@@ -0,0 +1,35 @@
+/*
+ * @author max
+ */
+package org.jetbrains.jet.lexer;
+
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+
+public class JetKeywordToken extends JetToken {
+
+    public static JetKeywordToken keyword(String value) {
+        return new JetKeywordToken(value, false);
+    }
+
+    public static JetKeywordToken softKeyword(String value) {
+        return new JetKeywordToken(value, true);
+    }
+
+    private final String myValue;
+    private final boolean myIsSoft;
+
+    private JetKeywordToken(@NotNull @NonNls String value, boolean isSoft) {
+        super(value);
+        myValue = value;
+        myIsSoft = isSoft;
+    }
+
+    public String getValue() {
+        return myValue;
+    }
+
+    public boolean isSoft() {
+        return myIsSoft;
+    }
+}

idea/src/org/jetbrains/jet/lexer/JetSoftKeywordToken.java

@@ -1,20 +0,0 @@
-/*
- * @author max
- */
-package org.jetbrains.jet.lexer;
-
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-
-public class JetSoftKeywordToken extends JetToken {
-    private final String myValue;
-
-    public JetSoftKeywordToken(@NotNull @NonNls String value) {
-        super(value);
-        myValue = value;
-    }
-
-    public String getValue() {
-        return myValue;
-    }
-}

idea/src/org/jetbrains/jet/lexer/JetTokens.java

@@ -6,10 +6,6 @@ package org.jetbrains.jet.lexer;
 import com.intellij.psi.TokenType;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
-import gnu.trove.THashSet;
-
-import java.util.Arrays;
-import java.util.Set;
 
 public interface JetTokens {
     JetToken EOF   = new JetToken("EOF");
@@ -26,35 +22,35 @@ public interface JetTokens {
     JetToken STRING_LITERAL     = new JetToken("STRING_LITERAL");
     JetToken RAW_STRING_LITERAL = new JetToken("RAW_STRING_LITERAL");
 
-    JetToken NAMESPACE_KEYWORD  = new JetToken("NAMESPACE_KEYWORD");
+    JetKeywordToken NAMESPACE_KEYWORD  = JetKeywordToken.keyword("namespace");
-    JetToken AS_KEYWORD         = new JetToken("AS_KEYWORD");
+    JetKeywordToken AS_KEYWORD         = JetKeywordToken.keyword("as");
-    JetToken TYPE_KEYWORD       = new JetToken("TYPE_KEYWORD");
+    JetKeywordToken TYPE_KEYWORD       = JetKeywordToken.keyword("type");
-    JetToken CLASS_KEYWORD      = new JetToken("CLASS_KEYWORD");
+    JetKeywordToken CLASS_KEYWORD      = JetKeywordToken.keyword("class");
-    JetToken THIS_KEYWORD       = new JetToken("THIS_KEYWORD");
+    JetKeywordToken THIS_KEYWORD       = JetKeywordToken.keyword("this");
-    JetToken VAL_KEYWORD        = new JetToken("VAL_KEYWORD");
+    JetKeywordToken VAL_KEYWORD        = JetKeywordToken.keyword("val");
-    JetToken VAR_KEYWORD        = new JetToken("VAR_KEYWORD");
+    JetKeywordToken VAR_KEYWORD        = JetKeywordToken.keyword("var");
-    JetToken FUN_KEYWORD        = new JetToken("FUN_KEYWORD");
+    JetKeywordToken FUN_KEYWORD        = JetKeywordToken.keyword("fun");
-    JetToken DECOMPOSER_KEYWORD = new JetToken("DECOMPOSER_KEYWORD");
+    JetKeywordToken DECOMPOSER_KEYWORD = JetKeywordToken.keyword("decomposer");
-    JetToken EXTENSION_KEYWORD  = new JetToken("EXTENSION_KEYWORD");
+    JetKeywordToken EXTENSION_KEYWORD  = JetKeywordToken.keyword("extension");
-    JetToken FOR_KEYWORD        = new JetToken("FOR_KEYWORD");
+    JetKeywordToken FOR_KEYWORD        = JetKeywordToken.keyword("for");
-    JetToken NULL_KEYWORD       = new JetToken("NULL_KEYWORD");
+    JetKeywordToken NULL_KEYWORD       = JetKeywordToken.keyword("null");
-    JetToken TYPEOF_KEYWORD     = new JetToken("TYPEOF_KEYWORD");
+    JetKeywordToken TYPEOF_KEYWORD     = JetKeywordToken.keyword("typeof");
-    JetToken NEW_KEYWORD        = new JetToken("NEW_KEYWORD");
+    JetKeywordToken NEW_KEYWORD        = JetKeywordToken.keyword("new");
-    JetToken TRUE_KEYWORD       = new JetToken("TRUE_KEYWORD");
+    JetKeywordToken TRUE_KEYWORD       = JetKeywordToken.keyword("true");
-    JetToken FALSE_KEYWORD      = new JetToken("FALSE_KEYWORD");
+    JetKeywordToken FALSE_KEYWORD      = JetKeywordToken.keyword("false");
-    JetToken IS_KEYWORD         = new JetToken("IS_KEYWORD");
+    JetKeywordToken IS_KEYWORD         = JetKeywordToken.keyword("is");
-    JetToken ISNOT_KEYWORD      = new JetToken("ISNOT_KEYWORD");
+    JetKeywordToken ISNOT_KEYWORD      = JetKeywordToken.keyword("isnot");
-    JetToken IN_KEYWORD         = new JetToken("IN_KEYWORD");
+    JetKeywordToken IN_KEYWORD         = JetKeywordToken.keyword("in");
-    JetToken THROW_KEYWORD      = new JetToken("THROW_KEYWORD");
+    JetKeywordToken THROW_KEYWORD      = JetKeywordToken.keyword("throw");
-    JetToken RETURN_KEYWORD     = new JetToken("RETURN_KEYWORD");
+    JetKeywordToken RETURN_KEYWORD     = JetKeywordToken.keyword("return");
-    JetToken BREAK_KEYWORD      = new JetToken("BREAK_KEYWORD");
+    JetKeywordToken BREAK_KEYWORD      = JetKeywordToken.keyword("break");
-    JetToken CONTINUE_KEYWORD   = new JetToken("CONTINUE_KEYWORD");
+    JetKeywordToken CONTINUE_KEYWORD   = JetKeywordToken.keyword("continue");
-    JetToken OBJECT_KEYWORD     = new JetToken("OBJECT_KEYWORD");
+    JetKeywordToken OBJECT_KEYWORD     = JetKeywordToken.keyword("object");
-    JetToken IF_KEYWORD         = new JetToken("IF_KEYWORD");
+    JetKeywordToken IF_KEYWORD         = JetKeywordToken.keyword("if");
-    JetToken ELSE_KEYWORD       = new JetToken("ELSE_KEYWORD");
+    JetKeywordToken ELSE_KEYWORD       = JetKeywordToken.keyword("else");
-    JetToken WHILE_KEYWORD      = new JetToken("WHILE_KEYWORD");
+    JetKeywordToken WHILE_KEYWORD      = JetKeywordToken.keyword("while");
-    JetToken DO_KEYWORD         = new JetToken("DO_KEYWORD");
+    JetKeywordToken DO_KEYWORD         = JetKeywordToken.keyword("do");
-    JetToken MATCH_KEYWORD      = new JetToken("MATCH_KEYWORD");
+    JetKeywordToken MATCH_KEYWORD      = JetKeywordToken.keyword("match");
 
 
     JetToken IDENTIFIER = new JetToken("IDENTIFIER");
@@ -101,37 +97,41 @@ public interface JetTokens {
 
     JetToken EOL_OR_SEMICOLON   = new JetToken("EOL_OR_SEMICOLON");
 
-    JetSoftKeywordToken WRAPS_KEYWORD     = new JetSoftKeywordToken("wraps");
+    JetKeywordToken WRAPS_KEYWORD     = JetKeywordToken.softKeyword("wraps");
-    JetSoftKeywordToken IMPORT_KEYWORD    = new JetSoftKeywordToken("import");
+    JetKeywordToken IMPORT_KEYWORD    = JetKeywordToken.softKeyword("import");
-    JetSoftKeywordToken WHERE_KEYWORD     = new JetSoftKeywordToken("where");
+    JetKeywordToken WHERE_KEYWORD     = JetKeywordToken.softKeyword("where");
-    JetSoftKeywordToken BY_KEYWORD        = new JetSoftKeywordToken("by");
+    JetKeywordToken BY_KEYWORD        = JetKeywordToken.softKeyword("by");
-    JetSoftKeywordToken LAZY_KEYWORD      = new JetSoftKeywordToken("lazy");
+    JetKeywordToken LAZY_KEYWORD      = JetKeywordToken.softKeyword("lazy");
-    JetSoftKeywordToken GET_KEYWORD       = new JetSoftKeywordToken("get");
+    JetKeywordToken GET_KEYWORD       = JetKeywordToken.softKeyword("get");
-    JetSoftKeywordToken SET_KEYWORD       = new JetSoftKeywordToken("set");
+    JetKeywordToken SET_KEYWORD       = JetKeywordToken.softKeyword("set");
-    JetSoftKeywordToken ABSTRACT_KEYWORD  = new JetSoftKeywordToken("abstract");
+    JetKeywordToken ABSTRACT_KEYWORD  = JetKeywordToken.softKeyword("abstract");
-    JetSoftKeywordToken VIRTUAL_KEYWORD   = new JetSoftKeywordToken("virtual");
+    JetKeywordToken VIRTUAL_KEYWORD   = JetKeywordToken.softKeyword("virtual");
-    JetSoftKeywordToken ENUM_KEYWORD      = new JetSoftKeywordToken("enum");
+    JetKeywordToken ENUM_KEYWORD      = JetKeywordToken.softKeyword("enum");
-    JetSoftKeywordToken OPEN_KEYWORD      = new JetSoftKeywordToken("open");
+    JetKeywordToken OPEN_KEYWORD      = JetKeywordToken.softKeyword("open");
-    JetSoftKeywordToken ATTRIBUTE_KEYWORD = new JetSoftKeywordToken("attribute");
+    JetKeywordToken ATTRIBUTE_KEYWORD = JetKeywordToken.softKeyword("attribute");
-    JetSoftKeywordToken OVERRIDE_KEYWORD  = new JetSoftKeywordToken("override");
+    JetKeywordToken OVERRIDE_KEYWORD  = JetKeywordToken.softKeyword("override");
-    JetSoftKeywordToken PRIVATE_KEYWORD   = new JetSoftKeywordToken("private");
+    JetKeywordToken PRIVATE_KEYWORD   = JetKeywordToken.softKeyword("private");
-    JetSoftKeywordToken PUBLIC_KEYWORD    = new JetSoftKeywordToken("public");
+    JetKeywordToken PUBLIC_KEYWORD    = JetKeywordToken.softKeyword("public");
-    JetSoftKeywordToken INTERNAL_KEYWORD  = new JetSoftKeywordToken("internal");
+    JetKeywordToken INTERNAL_KEYWORD  = JetKeywordToken.softKeyword("internal");
-    JetSoftKeywordToken PROTECTED_KEYWORD = new JetSoftKeywordToken("protected");
+    JetKeywordToken PROTECTED_KEYWORD = JetKeywordToken.softKeyword("protected");
-    JetSoftKeywordToken OUT_KEYWORD       = new JetSoftKeywordToken("out");
+    JetKeywordToken OUT_KEYWORD       = JetKeywordToken.softKeyword("out");
-    JetSoftKeywordToken REF_KEYWORD       = new JetSoftKeywordToken("ref");
+    JetKeywordToken REF_KEYWORD       = JetKeywordToken.softKeyword("ref");
 
     TokenSet KEYWORDS = TokenSet.create(NAMESPACE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, CLASS_KEYWORD,
             THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, DECOMPOSER_KEYWORD, EXTENSION_KEYWORD, FOR_KEYWORD,
             NULL_KEYWORD, TYPEOF_KEYWORD, NEW_KEYWORD, TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD, ISNOT_KEYWORD,
             IN_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD,
-            ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, MATCH_KEYWORD
+            ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, MATCH_KEYWORD, REF_KEYWORD, OUT_KEYWORD
     );
 
     TokenSet SOFT_KEYWORDS = TokenSet.create(WRAPS_KEYWORD, IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, LAZY_KEYWORD, GET_KEYWORD,
             SET_KEYWORD, ABSTRACT_KEYWORD, VIRTUAL_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, ATTRIBUTE_KEYWORD,
-            OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD,
+            OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD
-            REF_KEYWORD
+    );
+
+    TokenSet MODIFIER_KEYWORDS = TokenSet.create(LAZY_KEYWORD, ABSTRACT_KEYWORD, VIRTUAL_KEYWORD, ENUM_KEYWORD,
+            OPEN_KEYWORD, ATTRIBUTE_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD,
+            PROTECTED_KEYWORD, REF_KEYWORD, OUT_KEYWORD, IN_KEYWORD
     );
 
     TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.create(WHITE_SPACE, BLOCK_COMMENT, EOL_COMMENT, DOC_COMMENT);

idea/testData/psi/BabySteps.txt

@@ -1,12 +1,12 @@
 JetFile: BabySteps.jet
   NAMESPACE
-    PsiElement(NAMESPACE_KEYWORD)('namespace')
+    PsiElement(namespace)('namespace')
     PsiWhiteSpace(' ')
     NAMESPACE_NAME
       PsiElement(IDENTIFIER)('foo')
     PsiWhiteSpace('\n\n')
     CLASS
-      PsiElement(CLASS_KEYWORD)('class')
+      PsiElement(class)('class')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('Runnable')
       TYPE_PARAMETER_LIST

idea/testData/psi/ImportSoftKW.txt

@@ -11,6 +11,6 @@ JetFile: ImportSoftKW.jet
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('import')
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('import')

idea/testData/psi/Imports.txt

@@ -1,6 +1,6 @@
 JetFile: Imports.jet
   NAMESPACE
-    PsiElement(NAMESPACE_KEYWORD)('namespace')
+    PsiElement(namespace)('namespace')
     PsiWhiteSpace(' ')
     NAMESPACE_NAME
       PsiElement(IDENTIFIER)('foo')
@@ -26,7 +26,7 @@ JetFile: Imports.jet
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('bar')
     PsiWhiteSpace('\n')
@@ -37,7 +37,7 @@ JetFile: Imports.jet
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('bar')
     PsiWhiteSpace('\n')

idea/testData/psi/Imports_ERR.txt

@@ -1,6 +1,6 @@
 JetFile: Imports_ERR.jet
   NAMESPACE
-    PsiElement(NAMESPACE_KEYWORD)('namespace')
+    PsiElement(namespace)('namespace')
     PsiWhiteSpace(' ')
     NAMESPACE_NAME
       PsiElement(IDENTIFIER)('foo')
@@ -14,7 +14,7 @@ JetFile: Imports_ERR.jet
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace('\n')
       PsiElement(IDENTIFIER)('import')
     PsiWhiteSpace(' ')
@@ -39,7 +39,7 @@ JetFile: Imports_ERR.jet
       PsiElement(DOT)('.')
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting namespace or top level declaration
       PsiElement(IDENTIFIER)('bar')
@@ -53,7 +53,7 @@ JetFile: Imports_ERR.jet
       PsiElement(MAP)('.*')
       PsiWhiteSpace(' ')
       PsiErrorElement:Cannot rename a all imported items to one identifier
-        PsiElement(AS_KEYWORD)('as')
+        PsiElement(as)('as')
         PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('bar')
     PsiWhiteSpace('\n')
@@ -66,7 +66,7 @@ JetFile: Imports_ERR.jet
       PsiElement(MAP)('.*')
       PsiWhiteSpace(' ')
       PsiErrorElement:Cannot rename a all imported items to one identifier
-        PsiElement(AS_KEYWORD)('as')
+        PsiElement(as)('as')
         PsiWhiteSpace('\n\n')
         PsiElement(IDENTIFIER)('import')
     PsiWhiteSpace(' ')
@@ -74,7 +74,7 @@ JetFile: Imports_ERR.jet
       PsiElement(IDENTIFIER)('foo')
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting namespace or top level declaration
       PsiElement(SEMICOLON)(';')
@@ -109,7 +109,7 @@ JetFile: Imports_ERR.jet
       PsiErrorElement:Qualified name must be a '.'-separated identifier list
         <empty list>
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace(' ')
@@ -124,7 +124,7 @@ JetFile: Imports_ERR.jet
       PsiElement(MAP)('.*')
       PsiWhiteSpace(' ')
       PsiErrorElement:Cannot rename a all imported items to one identifier
-        PsiElement(AS_KEYWORD)('as')
+        PsiElement(as)('as')
         PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace(' ')
@@ -139,12 +139,12 @@ JetFile: Imports_ERR.jet
       PsiElement(MAP)('.*')
       PsiWhiteSpace(' ')
       PsiErrorElement:Cannot rename a all imported items to one identifier
-        PsiElement(AS_KEYWORD)('as')
+        PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(SEMICOLON)(';')
     PsiWhiteSpace('\n\n')
     CLASS
-      PsiElement(CLASS_KEYWORD)('class')
+      PsiElement(class)('class')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('Foo')
       PsiWhiteSpace(' ')

idea/testData/psi/NamespaceBlock.txt

@@ -1,6 +1,6 @@
 JetFile: NamespaceBlock.jet
   NAMESPACE
-    PsiElement(NAMESPACE_KEYWORD)('namespace')
+    PsiElement(namespace)('namespace')
     PsiWhiteSpace(' ')
     NAMESPACE_NAME
       PsiElement(IDENTIFIER)('foo')
@@ -14,12 +14,12 @@ JetFile: NamespaceBlock.jet
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('bar')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiWhiteSpace(' ')
       NAMESPACE_NAME
         PsiElement(IDENTIFIER)('foof')
@@ -37,7 +37,7 @@ JetFile: NamespaceBlock.jet
           PsiElement(SEMICOLON)(';')
         PsiWhiteSpace('\n\n    ')
         CLASS
-          PsiElement(CLASS_KEYWORD)('class')
+          PsiElement(class)('class')
           PsiWhiteSpace(' ')
           PsiElement(IDENTIFIER)('Foo')
           PsiWhiteSpace(' ')
@@ -48,7 +48,7 @@ JetFile: NamespaceBlock.jet
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         NAMESPACE
-          PsiElement(NAMESPACE_KEYWORD)('namespace')
+          PsiElement(namespace)('namespace')
           PsiWhiteSpace(' ')
           NAMESPACE_NAME
             PsiElement(IDENTIFIER)('bar')
@@ -57,7 +57,7 @@ JetFile: NamespaceBlock.jet
           PsiWhiteSpace('\n      ')
           NAMESPACE_BODY
             CLASS
-              PsiElement(CLASS_KEYWORD)('class')
+              PsiElement(class)('class')
               PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('Bar')
               PsiWhiteSpace(' ')
@@ -68,7 +68,7 @@ JetFile: NamespaceBlock.jet
                 PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n      ')
             NAMESPACE
-              PsiElement(NAMESPACE_KEYWORD)('namespace')
+              PsiElement(namespace)('namespace')
               PsiWhiteSpace(' ')
               NAMESPACE_NAME
                 PsiElement(IDENTIFIER)('ns')
@@ -77,14 +77,14 @@ JetFile: NamespaceBlock.jet
               PsiWhiteSpace('\n            ')
               NAMESPACE_BODY
                 CLASS
-                  PsiElement(CLASS_KEYWORD)('class')
+                  PsiElement(class)('class')
                   PsiWhiteSpace(' ')
                   PsiElement(IDENTIFIER)('X')
                   PsiWhiteSpace('\n\n            ')
                   TYPE_PARAMETER_LIST
                     <empty list>
                 CLASS
-                  PsiElement(CLASS_KEYWORD)('class')
+                  PsiElement(class)('class')
                   PsiWhiteSpace(' ')
                   PsiElement(IDENTIFIER)('Y')
                   PsiWhiteSpace('\n      ')
@@ -97,7 +97,7 @@ JetFile: NamespaceBlock.jet
       PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n\n')
     CLASS
-      PsiElement(CLASS_KEYWORD)('class')
+      PsiElement(class)('class')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('Bar')
       TYPE_PARAMETER_LIST
@@ -111,7 +111,7 @@ JetFile: NamespaceBlock.jet
         PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiWhiteSpace(' ')
       NAMESPACE_NAME
         PsiElement(IDENTIFIER)('foo')
@@ -122,7 +122,7 @@ JetFile: NamespaceBlock.jet
       PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiWhiteSpace(' ')
       NAMESPACE_NAME
         PsiElement(IDENTIFIER)('bar')

idea/testData/psi/NamespaceBlock_ERR.txt

@@ -1,6 +1,6 @@
 JetFile: NamespaceBlock_ERR.jet
   NAMESPACE
-    PsiElement(NAMESPACE_KEYWORD)('namespace')
+    PsiElement(namespace)('namespace')
     PsiWhiteSpace(' ')
     NAMESPACE_NAME
       PsiElement(IDENTIFIER)('foo')
@@ -14,7 +14,7 @@ JetFile: NamespaceBlock_ERR.jet
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
       PsiWhiteSpace(' ')
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
       PsiWhiteSpace('\n')
       PsiElement(IDENTIFIER)('import')
     PsiWhiteSpace(' ')
@@ -39,13 +39,13 @@ JetFile: NamespaceBlock_ERR.jet
       PsiElement(DOT)('.')
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(AS_KEYWORD)('as')
+      PsiElement(as)('as')
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting namespace or top level declaration
       PsiElement(IDENTIFIER)('bar')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiWhiteSpace(' ')
       NAMESPACE_NAME
         PsiElement(IDENTIFIER)('foof')
@@ -62,7 +62,7 @@ JetFile: NamespaceBlock_ERR.jet
           PsiElement(MAP)('.*')
           PsiWhiteSpace(' ')
           PsiErrorElement:Cannot rename a all imported items to one identifier
-            PsiElement(AS_KEYWORD)('as')
+            PsiElement(as)('as')
             PsiWhiteSpace(' ')
             PsiElement(IDENTIFIER)('bar')
         PsiWhiteSpace('\n    ')
@@ -75,7 +75,7 @@ JetFile: NamespaceBlock_ERR.jet
           PsiElement(MAP)('.*')
           PsiWhiteSpace(' ')
           PsiErrorElement:Cannot rename a all imported items to one identifier
-            PsiElement(AS_KEYWORD)('as')
+            PsiElement(as)('as')
             PsiWhiteSpace('\n\n    ')
             PsiElement(IDENTIFIER)('import')
         PsiWhiteSpace(' ')
@@ -83,7 +83,7 @@ JetFile: NamespaceBlock_ERR.jet
           PsiElement(IDENTIFIER)('foo')
         PsiWhiteSpace(' ')
         PsiErrorElement:Expecting namespace or top level declaration
-          PsiElement(AS_KEYWORD)('as')
+          PsiElement(as)('as')
         PsiWhiteSpace(' ')
         PsiErrorElement:Expecting namespace or top level declaration
           PsiElement(SEMICOLON)(';')
@@ -118,7 +118,7 @@ JetFile: NamespaceBlock_ERR.jet
           PsiErrorElement:Qualified name must be a '.'-separated identifier list
             <empty list>
           PsiWhiteSpace(' ')
-          PsiElement(AS_KEYWORD)('as')
+          PsiElement(as)('as')
           PsiWhiteSpace(' ')
           PsiElement(IDENTIFIER)('bar')
           PsiWhiteSpace(' ')
@@ -133,7 +133,7 @@ JetFile: NamespaceBlock_ERR.jet
           PsiElement(MAP)('.*')
           PsiWhiteSpace(' ')
           PsiErrorElement:Cannot rename a all imported items to one identifier
-            PsiElement(AS_KEYWORD)('as')
+            PsiElement(as)('as')
             PsiWhiteSpace(' ')
             PsiElement(IDENTIFIER)('bar')
           PsiWhiteSpace(' ')
@@ -148,12 +148,12 @@ JetFile: NamespaceBlock_ERR.jet
           PsiElement(MAP)('.*')
           PsiWhiteSpace(' ')
           PsiErrorElement:Cannot rename a all imported items to one identifier
-            PsiElement(AS_KEYWORD)('as')
+            PsiElement(as)('as')
           PsiWhiteSpace(' ')
           PsiElement(SEMICOLON)(';')
         PsiWhiteSpace('\n\n    ')
         NAMESPACE
-          PsiElement(NAMESPACE_KEYWORD)('namespace')
+          PsiElement(namespace)('namespace')
           PsiWhiteSpace(' ')
           NAMESPACE_NAME
             PsiElement(IDENTIFIER)('foo')
@@ -161,7 +161,7 @@ JetFile: NamespaceBlock_ERR.jet
             <empty list>
         PsiWhiteSpace('\n\n    ')
         CLASS
-          PsiElement(CLASS_KEYWORD)('class')
+          PsiElement(class)('class')
           PsiWhiteSpace(' ')
           PsiElement(IDENTIFIER)('Foo')
           PsiWhiteSpace(' ')
@@ -172,7 +172,7 @@ JetFile: NamespaceBlock_ERR.jet
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
         NAMESPACE
-          PsiElement(NAMESPACE_KEYWORD)('namespace')
+          PsiElement(namespace)('namespace')
           PsiErrorElement:Expecting namespace name
             <empty list>
           PsiWhiteSpace('  ')
@@ -180,7 +180,7 @@ JetFile: NamespaceBlock_ERR.jet
           PsiWhiteSpace('\n      ')
           NAMESPACE_BODY
             CLASS
-              PsiElement(CLASS_KEYWORD)('class')
+              PsiElement(class)('class')
               PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('Bar')
               PsiWhiteSpace(' ')
@@ -191,7 +191,7 @@ JetFile: NamespaceBlock_ERR.jet
                 PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n      ')
             NAMESPACE
-              PsiElement(NAMESPACE_KEYWORD)('namespace')
+              PsiElement(namespace)('namespace')
               PsiWhiteSpace(' ')
               NAMESPACE_NAME
                 PsiElement(IDENTIFIER)('ns')
@@ -200,14 +200,14 @@ JetFile: NamespaceBlock_ERR.jet
               PsiWhiteSpace('\n            ')
               NAMESPACE_BODY
                 CLASS
-                  PsiElement(CLASS_KEYWORD)('class')
+                  PsiElement(class)('class')
                   PsiWhiteSpace(' ')
                   PsiElement(IDENTIFIER)('X')
                   PsiWhiteSpace('\n\n            ')
                   TYPE_PARAMETER_LIST
                     <empty list>
                 CLASS
-                  PsiElement(CLASS_KEYWORD)('class')
+                  PsiElement(class)('class')
                   PsiWhiteSpace(' ')
                   PsiElement(IDENTIFIER)('Y')
                   PsiWhiteSpace('\n      ')
@@ -223,7 +223,7 @@ JetFile: NamespaceBlock_ERR.jet
       PsiElement(IDENTIFIER)('dsfgd')
     PsiWhiteSpace('\n\n')
     CLASS
-      PsiElement(CLASS_KEYWORD)('class')
+      PsiElement(class)('class')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('Bar')
       TYPE_PARAMETER_LIST
@@ -237,7 +237,7 @@ JetFile: NamespaceBlock_ERR.jet
         PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiWhiteSpace(' ')
       NAMESPACE_NAME
         PsiElement(IDENTIFIER)('foo')
@@ -245,7 +245,7 @@ JetFile: NamespaceBlock_ERR.jet
         <empty list>
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiErrorElement:Expecting namespace name
         <empty list>
       PsiWhiteSpace(' ')
@@ -255,7 +255,7 @@ JetFile: NamespaceBlock_ERR.jet
       PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(NAMESPACE_KEYWORD)('namespace')
+      PsiElement(namespace)('namespace')
       PsiWhiteSpace(' ')
       NAMESPACE_NAME
         PsiElement(IDENTIFIER)('bar')

idea/testData/psi/SimpleModifiers.jet

@@ -0,0 +1,51 @@
+namespace foo.bar.goo
+
+abstract
+virtual
+enum
+open
+attribute
+override
+virtual
+abstract
+private
+protected
+public
+internal
+lazy
+in
+out
+ref
+ class Bar<abstract
+virtual
+enum
+open
+attribute
+override
+virtual
+abstract
+private
+protected
+public
+internal
+lazy
+in
+out
+ref T> {
+abstract
+virtual
+enum
+open
+attribute
+override
+virtual
+abstract
+private
+protected
+public
+internal
+in
+lazy
+out
+ref
+}

idea/testData/psi/SimpleModifiers.txt

@@ -0,0 +1,123 @@
+JetFile: SimpleModifiers.jet
+  NAMESPACE
+    PsiElement(namespace)('namespace')
+    PsiWhiteSpace(' ')
+    NAMESPACE_NAME
+      PsiElement(IDENTIFIER)('foo')
+      PsiElement(DOT)('.')
+      PsiElement(IDENTIFIER)('bar')
+      PsiElement(DOT)('.')
+      PsiElement(IDENTIFIER)('goo')
+    PsiWhiteSpace('\n\n')
+    CLASS
+      MODIFIER_LIST
+        PsiElement(abstract)('abstract')
+        PsiWhiteSpace('\n')
+        PsiElement(virtual)('virtual')
+        PsiWhiteSpace('\n')
+        PsiElement(enum)('enum')
+        PsiWhiteSpace('\n')
+        PsiElement(open)('open')
+        PsiWhiteSpace('\n')
+        PsiElement(attribute)('attribute')
+        PsiWhiteSpace('\n')
+        PsiElement(override)('override')
+        PsiWhiteSpace('\n')
+        PsiElement(virtual)('virtual')
+        PsiWhiteSpace('\n')
+        PsiElement(abstract)('abstract')
+        PsiWhiteSpace('\n')
+        PsiElement(private)('private')
+        PsiWhiteSpace('\n')
+        PsiElement(protected)('protected')
+        PsiWhiteSpace('\n')
+        PsiElement(public)('public')
+        PsiWhiteSpace('\n')
+        PsiElement(internal)('internal')
+        PsiWhiteSpace('\n')
+        PsiElement(lazy)('lazy')
+        PsiWhiteSpace('\n')
+        PsiElement(in)('in')
+        PsiWhiteSpace('\n')
+        PsiElement(out)('out')
+        PsiWhiteSpace('\n')
+        PsiElement(ref)('ref')
+      PsiWhiteSpace('\n ')
+      PsiElement(class)('class')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('Bar')
+      TYPE_PARAMETER_LIST
+        PsiElement(LT)('<')
+        TYPE_PARAMETER
+          MODIFIER_LIST
+            PsiElement(abstract)('abstract')
+            PsiWhiteSpace('\n')
+            PsiElement(virtual)('virtual')
+            PsiWhiteSpace('\n')
+            PsiElement(enum)('enum')
+            PsiWhiteSpace('\n')
+            PsiElement(open)('open')
+            PsiWhiteSpace('\n')
+            PsiElement(attribute)('attribute')
+            PsiWhiteSpace('\n')
+            PsiElement(override)('override')
+            PsiWhiteSpace('\n')
+            PsiElement(virtual)('virtual')
+            PsiWhiteSpace('\n')
+            PsiElement(abstract)('abstract')
+            PsiWhiteSpace('\n')
+            PsiElement(private)('private')
+            PsiWhiteSpace('\n')
+            PsiElement(protected)('protected')
+            PsiWhiteSpace('\n')
+            PsiElement(public)('public')
+            PsiWhiteSpace('\n')
+            PsiElement(internal)('internal')
+            PsiWhiteSpace('\n')
+            PsiElement(lazy)('lazy')
+            PsiWhiteSpace('\n')
+            PsiElement(in)('in')
+            PsiWhiteSpace('\n')
+            PsiElement(out)('out')
+            PsiWhiteSpace('\n')
+            PsiElement(ref)('ref')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('T')
+        PsiElement(GT)('>')
+      PsiWhiteSpace(' ')
+      CLASS_BODY
+        PsiElement(LBRACE)('{')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('abstract')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('virtual')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('enum')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('open')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('attribute')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('override')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('virtual')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('abstract')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('private')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('protected')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('public')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('internal')
+        PsiWhiteSpace('\n')
+        PsiElement(in)('in')
+        PsiWhiteSpace('\n')
+        PsiElement(IDENTIFIER)('lazy')
+        PsiWhiteSpace('\n')
+        PsiElement(out)('out')
+        PsiWhiteSpace('\n')
+        PsiElement(ref)('ref')
+        PsiWhiteSpace('\n')
+        PsiElement(RBRACE)('}')

idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java

@@ -34,4 +34,5 @@ public class JetParsingTest extends ParsingTestCase {
     public void testImportSoftKW() throws Exception {doTest(true);}
     public void testNamespaceBlock_ERR() throws Exception {doTest(true);}
     public void testNamespaceBlock() throws Exception {doTest(true);}
+    public void testSimpleModifiers() throws Exception {doTest(true);}
 }