[java] hasModifierProperty: deduplicate and cache; change PsiAugmentProvider API while we still can

java/java-psi-api/src/com/intellij/psi/augment/PsiAugmentProvider.java

@@ -34,6 +34,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 /**
  * Some code is not what it seems to be!
@@ -75,9 +76,9 @@ public abstract class PsiAugmentProvider {
    *
    * @since 2016.2
    */
-  @Nullable
-  protected Boolean hasModifierProperty(@NotNull PsiModifierList modifierList, @NotNull String name) {
-    return null;
+  @NotNull
+  protected Set<String> transformModifiers(@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) {
+    return modifiers;
   }
 
   //</editor-fold>
@@ -120,21 +121,17 @@ public abstract class PsiAugmentProvider {
     return result.get();
   }
 
-  @Nullable
-  public static Boolean checkModifierProperty(@NotNull final PsiModifierList modifierList, @NotNull final String name) {
-    final Ref<Boolean> result = Ref.create();
+  @NotNull
+  public static Set<String> transformModifierProperties(@NotNull final PsiModifierList modifierList,
+                                                        @NotNull Project project,
+                                                        @NotNull final Set<String> modifiers) {
+    final Ref<Set<String>> result = Ref.create(modifiers);
 
-    forEach(modifierList.getProject(), new Processor<PsiAugmentProvider>() {
+    forEach(project, new Processor<PsiAugmentProvider>() {
       @Override
       public boolean process(PsiAugmentProvider provider) {
-        Boolean property = provider.hasModifierProperty(modifierList, name);
-        if (property != null) {
-          result.set(property);
-          return false;
-        }
-        else {
-          return true;
-        }
+        result.set(provider.transformModifiers(modifierList, Collections.unmodifiableSet(result.get())));
+        return true;
       }
     });
 

java/java-psi-impl/src/com/intellij/psi/impl/cache/ModifierFlags.java

@@ -19,6 +19,7 @@ import com.intellij.psi.JavaTokenType;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.util.BitUtil;
+import gnu.trove.TIntObjectHashMap;
 import gnu.trove.TObjectIntHashMap;
 
 /**
@@ -40,6 +41,7 @@ public final class ModifierFlags {
   public static final int PACKAGE_LOCAL_MASK = 0x1000;
 
   public static final TObjectIntHashMap<String> NAME_TO_MODIFIER_FLAG_MAP = new TObjectIntHashMap<String>();
+  public static final TIntObjectHashMap<String> MODIFIER_FLAG_TO_NAME_MAP = new TIntObjectHashMap<String>();
   public static final TObjectIntHashMap<IElementType> KEYWORD_TO_MODIFIER_FLAG_MAP = new TObjectIntHashMap<IElementType>();
   static {
     NAME_TO_MODIFIER_FLAG_MAP.put(PsiModifier.PUBLIC, PUBLIC_MASK);
@@ -56,6 +58,10 @@ public final class ModifierFlags {
     NAME_TO_MODIFIER_FLAG_MAP.put(PsiModifier.STRICTFP, STRICTFP_MASK);
     NAME_TO_MODIFIER_FLAG_MAP.put(PsiModifier.PACKAGE_LOCAL, PACKAGE_LOCAL_MASK);
 
+    for (Object name : NAME_TO_MODIFIER_FLAG_MAP.keys()) {
+      MODIFIER_FLAG_TO_NAME_MAP.put(NAME_TO_MODIFIER_FLAG_MAP.get((String)name), (String)name);
+    }
+
     KEYWORD_TO_MODIFIER_FLAG_MAP.put(JavaTokenType.PUBLIC_KEYWORD, PUBLIC_MASK);
     KEYWORD_TO_MODIFIER_FLAG_MAP.put(JavaTokenType.PRIVATE_KEYWORD, PRIVATE_MASK);
     KEYWORD_TO_MODIFIER_FLAG_MAP.put(JavaTokenType.PROTECTED_KEYWORD, PROTECTED_MASK);

java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java

@@ -21,18 +21,17 @@ import com.intellij.lang.LighterASTTokenNode;
 import com.intellij.psi.JavaTokenType;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.PsiModifierList;
-import com.intellij.psi.impl.java.stubs.*;
+import com.intellij.psi.impl.java.stubs.JavaStubElementTypes;
+import com.intellij.psi.impl.java.stubs.PsiClassStub;
+import com.intellij.psi.impl.java.stubs.PsiFieldStub;
+import com.intellij.psi.impl.java.stubs.PsiModifierListStub;
 import com.intellij.psi.impl.source.tree.JavaElementType;
 import com.intellij.psi.impl.source.tree.LightTreeUtil;
-import com.intellij.psi.stubs.PsiFileStub;
 import com.intellij.psi.stubs.StubElement;
-import com.intellij.util.BitUtil;
 import com.intellij.util.CharTable;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.List;
-
 /**
  * @author max
  */
@@ -65,81 +64,11 @@ public class RecordUtil {
     return text.contains(DEPRECATED_TAG);
   }
 
-  public static int packModifierList(@NotNull LighterAST tree, @NotNull LighterASTNode modList, @NotNull StubElement parent) {
+  public static int packModifierList(@NotNull LighterAST tree, @NotNull LighterASTNode modList) {
     int packed = 0;
-
-    final LighterASTNode modListOwner = tree.getParent(modList);
-    if (modListOwner != null && modListOwner.getTokenType() == parent.getStubType()) {
-      final StubElement grandParent = parent.getParentStub();
-      if (parent instanceof PsiClassStub) {
-        if (grandParent instanceof PsiClassStub && ((PsiClassStub)grandParent).isInterface()) {
-          packed |= ModifierFlags.PUBLIC_MASK;
-          packed |= ModifierFlags.STATIC_MASK;
-        }
-        if (((PsiClassStub)parent).isInterface()) {
-          packed |= ModifierFlags.ABSTRACT_MASK;
-          if (grandParent instanceof PsiClassStub) {
-            packed |= ModifierFlags.STATIC_MASK;
-          }
-        }
-        else if (((PsiClassStub)parent).isEnum()) {
-          if (!(grandParent instanceof PsiFileStub)) {
-            packed |= ModifierFlags.STATIC_MASK;
-          }
-
-          boolean isFinal = true;
-          final List<LighterASTNode> enumConstants = LightTreeUtil.getChildrenOfType(tree, modListOwner, JavaElementType.ENUM_CONSTANT);
-          for (final LighterASTNode constant : enumConstants) {
-            if (LightTreeUtil.firstChildOfType(tree, constant, JavaElementType.ENUM_CONSTANT_INITIALIZER) != null) {
-              isFinal = false;
-              break;
-            }
-          }
-          if (isFinal) {
-            packed |= ModifierFlags.FINAL_MASK;
-          }
-
-          final List<LighterASTNode> methods = LightTreeUtil.getChildrenOfType(tree, modListOwner, JavaElementType.METHOD);
-          for (final LighterASTNode method : methods) {
-            final LighterASTNode mods = LightTreeUtil.requiredChildOfType(tree, method, JavaElementType.MODIFIER_LIST);
-            if (LightTreeUtil.firstChildOfType(tree, mods, JavaTokenType.ABSTRACT_KEYWORD) != null) {
-              packed |= ModifierFlags.ABSTRACT_MASK;
-              break;
-            }
-          }
-        }
-      }
-      else if (parent instanceof PsiMethodStub) {
-        if (grandParent instanceof PsiClassStub && ((PsiClassStub)grandParent).isInterface()) {
-          packed |= ModifierFlags.PUBLIC_MASK;
-          packed |= ModifierFlags.ABSTRACT_MASK;
-        }
-      }
-      else if (parent instanceof PsiFieldStub) {
-        if (parent.getStubType() == JavaElementType.ENUM_CONSTANT ||
-            grandParent instanceof PsiClassStub && ((PsiClassStub)grandParent).isInterface()) {
-          packed |= ModifierFlags.PUBLIC_MASK;
-          packed |= ModifierFlags.STATIC_MASK;
-          packed |= ModifierFlags.FINAL_MASK;
-        }
-      }
-    }
-
     for (final LighterASTNode child : tree.getChildren(modList)) {
-      final int flag = ModifierFlags.KEYWORD_TO_MODIFIER_FLAG_MAP.get(child.getTokenType());
-      if (flag != 0) {
-        packed |= flag;
-      }
+      packed |= ModifierFlags.KEYWORD_TO_MODIFIER_FLAG_MAP.get(child.getTokenType());
     }
-
-    if (BitUtil.isSet(packed, ModifierFlags.DEFENDER_MASK)) {
-      packed &= ~ModifierFlags.ABSTRACT_MASK;
-    }
-
-    if ((packed & (ModifierFlags.PRIVATE_MASK | ModifierFlags.PROTECTED_MASK | ModifierFlags.PUBLIC_MASK)) == 0) {
-      packed |= ModifierFlags.PACKAGE_LOCAL_MASK;
-    }
-
     return packed;
   }
 
@@ -156,6 +85,16 @@ public class RecordUtil {
     }
 
     int mask = ((PsiModifierListStub)type).getModifiersMask();
-    return ModifierFlags.hasModifierProperty(PsiModifier.STATIC, mask) && !ModifierFlags.hasModifierProperty(PsiModifier.PRIVATE, mask);
+    if (ModifierFlags.hasModifierProperty(PsiModifier.PRIVATE, mask)) {
+      return false;
+    }
+
+    if (ModifierFlags.hasModifierProperty(PsiModifier.STATIC, mask)) {
+      return true;
+    }
+
+    return stub instanceof PsiFieldStub &&
+           stub.getStubType() == JavaElementType.ENUM_CONSTANT ||
+           stub.getParentStub() instanceof PsiClassStub && ((PsiClassStub)stub.getParentStub()).isInterface();
   }
 }

java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaModifierListElementType.java

@@ -60,7 +60,7 @@ public class JavaModifierListElementType extends JavaStubElementType<PsiModifier
 
   @Override
   public PsiModifierListStub createStub(final LighterAST tree, final LighterASTNode node, final StubElement parentStub) {
-    return new PsiModifierListStubImpl(parentStub, RecordUtil.packModifierList(tree, node, parentStub));
+    return new PsiModifierListStubImpl(parentStub, RecordUtil.packModifierList(tree, node));
   }
 
   @Override

java/java-psi-impl/src/com/intellij/psi/impl/source/JavaFileElementType.java

@@ -42,7 +42,7 @@ import java.io.IOException;
  * @author max
  */
 public class JavaFileElementType extends ILightStubFileElementType<PsiJavaFileStub> {
-  public static final int STUB_VERSION = 23;
+  public static final int STUB_VERSION = 24;
 
   public JavaFileElementType() {
     super("java.FILE", JavaLanguage.INSTANCE);

java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java

@@ -31,33 +31,44 @@ import com.intellij.psi.impl.source.tree.Factory;
 import com.intellij.psi.impl.source.tree.TreeElement;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.util.ArrayUtil;
+import com.intellij.util.BitUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.WeakInterner;
 import gnu.trove.THashMap;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+
+import static com.intellij.psi.PsiModifier.*;
 
 public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub> implements PsiModifierList {
   private static final Map<String, IElementType> NAME_TO_KEYWORD_TYPE_MAP;
+  private static final Map<IElementType, String> KEYWORD_TYPE_TO_NAME_MAP;
   static {
     NAME_TO_KEYWORD_TYPE_MAP = new THashMap<String, IElementType>();
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.PUBLIC, JavaTokenType.PUBLIC_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.PROTECTED, JavaTokenType.PROTECTED_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.PRIVATE, JavaTokenType.PRIVATE_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.STATIC, JavaTokenType.STATIC_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.ABSTRACT, JavaTokenType.ABSTRACT_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.FINAL, JavaTokenType.FINAL_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.NATIVE, JavaTokenType.NATIVE_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.SYNCHRONIZED, JavaTokenType.SYNCHRONIZED_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.STRICTFP, JavaTokenType.STRICTFP_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.TRANSIENT, JavaTokenType.TRANSIENT_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.VOLATILE, JavaTokenType.VOLATILE_KEYWORD);
-    NAME_TO_KEYWORD_TYPE_MAP.put(PsiModifier.DEFAULT, JavaTokenType.DEFAULT_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(PUBLIC, JavaTokenType.PUBLIC_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(PROTECTED, JavaTokenType.PROTECTED_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(PRIVATE, JavaTokenType.PRIVATE_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(STATIC, JavaTokenType.STATIC_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(ABSTRACT, JavaTokenType.ABSTRACT_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(FINAL, JavaTokenType.FINAL_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(NATIVE, JavaTokenType.NATIVE_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(SYNCHRONIZED, JavaTokenType.SYNCHRONIZED_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(STRICTFP, JavaTokenType.STRICTFP_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(TRANSIENT, JavaTokenType.TRANSIENT_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(VOLATILE, JavaTokenType.VOLATILE_KEYWORD);
+    NAME_TO_KEYWORD_TYPE_MAP.put(DEFAULT, JavaTokenType.DEFAULT_KEYWORD);
+
+    KEYWORD_TYPE_TO_NAME_MAP = ContainerUtil.newTroveMap();
+    for (String name : NAME_TO_KEYWORD_TYPE_MAP.keySet()) {
+      KEYWORD_TYPE_TO_NAME_MAP.put(NAME_TO_KEYWORD_TYPE_MAP.get(name), name);
+    }
   }
 
+  private volatile ModifierCache myModifierCache;
+
   public PsiModifierListImpl(final PsiModifierListStub stub) {
     super(stub, JavaStubElementTypes.MODIFIER_LIST);
   }
@@ -68,120 +79,113 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
 
   @Override
   public boolean hasModifierProperty(@NotNull String name) {
-    Boolean augmentation = PsiAugmentProvider.checkModifierProperty(this, name);
-    if (augmentation != null) return augmentation;
+    ModifierCache modifierCache = myModifierCache;
+    if (modifierCache == null || !modifierCache.isUpToDate()) {
+      myModifierCache = modifierCache = calcModifiers();
+    }
+    return modifierCache.modifiers.contains(name);
+  }
 
+  private ModifierCache calcModifiers() {
+    Set<String> modifiers = calcExplicitModifiers();
+    modifiers.addAll(calcImplicitModifiers(modifiers));
+    if (!modifiers.contains(PUBLIC) && !modifiers.contains(PROTECTED) && !modifiers.contains(PRIVATE)) {
+      modifiers.add(PACKAGE_LOCAL);
+    }
+    PsiFile file = getContainingFile();
+    return new ModifierCache(file, PsiAugmentProvider.transformModifierProperties(this, file.getProject(), modifiers));
+  }
+
+  private Set<String> calcExplicitModifiers() {
+    Set<String> explicitModifiers = ContainerUtil.newHashSet();
     PsiModifierListStub stub = getStub();
     if (stub != null) {
-      return ModifierFlags.hasModifierProperty(name, stub.getModifiersMask());
-    }
-
-    IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name);
-
-    PsiElement parent = getParent();
-    if (parent instanceof PsiClass) {
-      PsiElement grandParent = parent.getParent();
-      if (grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) {
-        if (type == JavaTokenType.PUBLIC_KEYWORD) {
-          return true;
-        }
-        if (type == null /* package-private */) {
-          return false;
-        }
-        if (type == JavaTokenType.STATIC_KEYWORD) {
-          return true;
+      int mask = stub.getModifiersMask();
+      for (int i = 0; i < 31; i++) {
+        int flag = 1 << i;
+        if (BitUtil.isSet(mask, flag)) {
+          ContainerUtil.addIfNotNull(explicitModifiers, ModifierFlags.MODIFIER_FLAG_TO_NAME_MAP.get(flag));
         }
       }
+    } else {
+      for (ASTNode child : getNode().getChildren(null)) {
+        ContainerUtil.addIfNotNull(explicitModifiers, KEYWORD_TYPE_TO_NAME_MAP.get(child.getElementType()));
+      }
+    }
+
+    return explicitModifiers;
+  }
+
+  private Set<String> calcImplicitModifiers(Set<String> explicitModifiers) {
+    Set<String> implicitModifiers = ContainerUtil.newHashSet();
+    PsiElement parent = getParent();
+    if (parent instanceof PsiClass) {
+      PsiElement grandParent = parent.getContext();
+      if (grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) {
+        Collections.addAll(implicitModifiers, PUBLIC, STATIC);
+      }
       if (((PsiClass)parent).isInterface()) {
-        if (type == JavaTokenType.ABSTRACT_KEYWORD) {
-          return true;
-        }
+        implicitModifiers.add(ABSTRACT);
 
         // nested interface is implicitly static
         if (grandParent instanceof PsiClass) {
-          if (type == JavaTokenType.STATIC_KEYWORD) {
-            return true;
-          }
+          implicitModifiers.add(STATIC);
         }
       }
       if (((PsiClass)parent).isEnum()) {
-        if (type == JavaTokenType.STATIC_KEYWORD) {
-          if (!(grandParent instanceof PsiFile)) return true;
+        if (!(grandParent instanceof PsiFile)) {
+          implicitModifiers.add(STATIC);
         }
-        else if (type == JavaTokenType.FINAL_KEYWORD) {
-          final PsiField[] fields = ((PsiClass)parent).getFields();
-          for (PsiField field : fields) {
-            if (field instanceof PsiEnumConstant && ((PsiEnumConstant)field).getInitializingClass() != null) return false;
+        boolean hasSubClass = ContainerUtil.find(((PsiClass)parent).getFields(), new Condition<PsiField>() {
+          @Override
+          public boolean value(PsiField field) {
+            return field instanceof PsiEnumConstant && ((PsiEnumConstant)field).getInitializingClass() != null;
           }
-          return true;
+        }) != null;
+        if (!hasSubClass) {
+          implicitModifiers.add(FINAL);
         }
-        else if (type == JavaTokenType.ABSTRACT_KEYWORD) {
-          final PsiMethod[] methods = ((PsiClass)parent).getMethods();
-          for (PsiMethod method : methods) {
-            if (method.hasModifierProperty(PsiModifier.ABSTRACT)) return true;
+
+        for (PsiMethod method : ((PsiClass)parent).getMethods()) {
+          if (method.hasModifierProperty(ABSTRACT)) {
+            implicitModifiers.add(ABSTRACT);
+            break;
           }
-          return false;
         }
       }
     }
     else if (parent instanceof PsiMethod) {
       PsiClass aClass = ((PsiMethod)parent).getContainingClass();
       if (aClass != null && aClass.isInterface()) {
-        if (type == JavaTokenType.PUBLIC_KEYWORD) {
-          return true;
-        }
-        if (type == null /* package-private */) {
-          return false;
-        }
-        if (type == JavaTokenType.ABSTRACT_KEYWORD) {
-          final ASTNode node = getNode();
-          return node.findChildByType(JavaTokenType.DEFAULT_KEYWORD) == null && 
-                 node.findChildByType(JavaTokenType.STATIC_KEYWORD) == null &&
-                 node.findChildByType(JavaTokenType.PRIVATE_KEYWORD) == null;
+        implicitModifiers.add(PUBLIC);
+        if (!explicitModifiers.contains(DEFAULT) && !explicitModifiers.contains(STATIC) && !explicitModifiers.contains(PRIVATE)) {
+          implicitModifiers.add(ABSTRACT);
         }
       }
       else if (aClass != null && aClass.isEnum() && ((PsiMethod)parent).isConstructor()) {
-        if (type == JavaTokenType.PRIVATE_KEYWORD) {
-          return true;
-        }
+        implicitModifiers.add(PRIVATE);
       }
     }
     else if (parent instanceof PsiField) {
       if (parent instanceof PsiEnumConstant) {
-        return type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.STATIC_KEYWORD || type == JavaTokenType.FINAL_KEYWORD;
+        Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL);
       }
       else {
         PsiClass aClass = ((PsiField)parent).getContainingClass();
         if (aClass != null && aClass.isInterface()) {
-          if (type == JavaTokenType.PUBLIC_KEYWORD) {
-            return true;
-          }
-          if (type == null /* package-private */) {
-            return false;
-          }
-          if (type == JavaTokenType.STATIC_KEYWORD) {
-            return true;
-          }
-          if (type == JavaTokenType.FINAL_KEYWORD) {
-            return true;
-          }
+          Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL);
         }
       }
     }
-    else if (parent instanceof PsiParameter) {
-      if (type == JavaTokenType.FINAL_KEYWORD && ((PsiParameter)parent).getType() instanceof PsiDisjunctionType) return true;
+    else if (parent instanceof PsiParameter &&
+             parent.getParent() instanceof PsiCatchSection &&
+             ((PsiParameter)parent).getType() instanceof PsiDisjunctionType) {
+      Collections.addAll(implicitModifiers, FINAL);
     }
     else if (parent instanceof PsiResourceVariable) {
-      if (type == JavaTokenType.FINAL_KEYWORD) return true;
+      Collections.addAll(implicitModifiers, FINAL);
     }
-
-    if (type == null /* package-private */) {
-      return !hasModifierProperty(PsiModifier.PUBLIC) &&
-             !hasModifierProperty(PsiModifier.PRIVATE) &&
-             !hasModifierProperty(PsiModifier.PROTECTED);
-    }
-
-    return getNode().findChildByType(type) != null;
+    return implicitModifiers;
   }
 
   @Override
@@ -213,13 +217,13 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
           type == JavaTokenType.PROTECTED_KEYWORD ||
           type == null /* package-private */) {
         if (type != JavaTokenType.PUBLIC_KEYWORD) {
-          setModifierProperty(PsiModifier.PUBLIC, false);
+          setModifierProperty(PUBLIC, false);
         }
         if (type != JavaTokenType.PRIVATE_KEYWORD) {
-          setModifierProperty(PsiModifier.PRIVATE, false);
+          setModifierProperty(PRIVATE, false);
         }
         if (type != JavaTokenType.PROTECTED_KEYWORD) {
-          setModifierProperty(PsiModifier.PROTECTED, false);
+          setModifierProperty(PROTECTED, false);
         }
         if (type == null) return;
       }
@@ -307,4 +311,27 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
   public String toString(){
     return "PsiModifierList:" + getText();
   }
+
+  private static class ModifierCache {
+    static final WeakInterner<List<String>> ourInterner = new WeakInterner<List<String>>();
+    final PsiFile file;
+    final List<String> modifiers;
+    final long modCount;
+
+    ModifierCache(@NotNull PsiFile file, @NotNull Set<String> modifiers) {
+      this.file = file;
+      List<String> modifierList = ContainerUtil.newArrayList(modifiers);
+      Collections.sort(modifierList);
+      this.modifiers = ourInterner.intern(modifierList);
+      this.modCount = getModCount();
+    }
+
+    private long getModCount() {
+      return file.getManager().getModificationTracker().getModificationCount() + file.getModificationStamp();
+    }
+
+    boolean isUpToDate() {
+      return getModCount() == modCount;
+    }
+  }
 }

java/java-tests/testSrc/com/intellij/codeInsight/daemon/PsiAugmentProviderTest.java

@@ -23,9 +23,13 @@ import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.testFramework.PlatformTestUtil;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
+import com.intellij.util.containers.ContainerUtil;
+import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Set;
+
 public class PsiAugmentProviderTest extends LightCodeInsightFixtureTestCase {
   @Override
   protected String getTestDataPath() {
@@ -105,10 +109,15 @@ public class PsiAugmentProviderTest extends LightCodeInsightFixtureTestCase {
       return null;
     }
 
-    @Nullable
+    @NotNull
     @Override
-    protected Boolean hasModifierProperty(@NotNull PsiModifierList modifierList, @NotNull String name) {
-      return (PsiModifier.FINAL.equals(name) && isLombokVal(modifierList.getParent())) ? Boolean.TRUE : null;
+    protected Set<String> transformModifiers(@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) {
+      if (isLombokVal(modifierList.getParent())) {
+        THashSet<String> result = ContainerUtil.newTroveSet(modifiers);
+        result.add(PsiModifier.FINAL);
+        return result;
+      }
+      return modifiers;
     }
 
     private static boolean isLombokVal(PsiElement variable) {

java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java

@@ -70,12 +70,12 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub [p]\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[name=A fqn=p.A]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:I, J<I>]\n" +
            "  CLASS:PsiClassStub[name=B fqn=p.B]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      TYPE_PARAMETER:PsiTypeParameter[K]\n" +
            "        EXTENDS_BOUND_LIST:PsiRefListStub[EXTENDS_BOUNDS_LIST:]\n" +
@@ -84,19 +84,19 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:a/*skip*/.A]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    CLASS:PsiClassStub[name=I fqn=p.B.I]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "      IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "  CLASS:PsiClassStub[interface deprecatedA name=I fqn=p.I]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=5120]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      ANNOTATION:PsiAnnotationStub[@java.lang.Deprecated]\n" +
            "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "  CLASS:PsiClassStub[interface annotation deprecated name=N fqn=p.N]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=5120]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n");
@@ -120,17 +120,17 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[interface annotation name=Anno fqn=Anno]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=1025]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=1]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    ANNOTATION_METHOD:PsiMethodStub[annotation i:int default=42]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=1025]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
            "    ANNOTATION_METHOD:PsiMethodStub[annotation s:String]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=1033]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=9]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
@@ -149,33 +149,33 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "        PARAMETER:PsiParameterStub[i:int]\n" +
-           "          MODIFIER_LIST:PsiModifierListStub[mask=4112]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=16]\n" +
            "        PARAMETER:PsiParameterStub[a1:int[]]\n" +
-           "          MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "        PARAMETER:PsiParameterStub[a2:int[]]\n" +
-           "          MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "        PARAMETER:PsiParameterStub[a3:int[][]]\n" +
-           "          MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
            "    METHOD:PsiMethodStub[varargs v2a:int[]]\n" +
            "      MODIFIER_LIST:PsiModifierListStub[mask=10]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "        PARAMETER:PsiParameterStub[v:int...]\n" +
-           "          MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
            "  CLASS:PsiClassStub[interface name=I fqn=I]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=5120]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    METHOD:PsiMethodStub[m1:void]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=1025]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
            "    METHOD:PsiMethodStub[m2:void]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=513]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=512]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n");
@@ -195,17 +195,17 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[name=C fqn=C]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4104]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=8]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    FIELD:PsiFieldStub[f:float]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=6144]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=2048]\n" +
            "    FIELD:PsiFieldStub[j:int[]={0}]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    FIELD:PsiFieldStub[k:int]\n" +
            "    FIELD:PsiFieldStub[s:String=\"-\"]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4104]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=8]\n" +
            "  CLASS:PsiClassStub[name=D fqn=D]\n" +
            "    MODIFIER_LIST:PsiModifierListStub[mask=1]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
@@ -227,12 +227,12 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[name=C fqn=C]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    CLASS_INITIALIZER:PsiClassInitializerStub\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      ANONYMOUS_CLASS:PsiClassStub[anonymous name=null fqn=null baseref=O.P]\n" +
            "      ANONYMOUS_CLASS:PsiClassStub[anonymous name=null fqn=null baseref=Y inqualifnew]\n" +
            "      ANONYMOUS_CLASS:PsiClassStub[anonymous name=null fqn=null baseref=R]\n");
@@ -248,27 +248,27 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[enum name=E fqn=E]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=5120]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    ENUM_CONSTANT:PsiFieldStub[enumconst E1:E]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=25]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      ENUM_CONSTANT_INITIALIZER:PsiClassStub[anonymous enumInit name=null fqn=null baseref=E]\n" +
            "    METHOD:PsiMethodStub[m:void]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=5120]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=1024]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
            "  CLASS:PsiClassStub[enum name=U fqn=U]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=17]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=1]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    ENUM_CONSTANT:PsiFieldStub[enumconst U1:U]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=25]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    ENUM_CONSTANT:PsiFieldStub[enumconst U2:U]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=25]\n");
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n");
   }
 
   public void testLocalVariables() {
@@ -290,12 +290,12 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[name=C fqn=C]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    METHOD:PsiMethodStub[m:void]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
@@ -331,12 +331,12 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[name=C fqn=C]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    CLASS_INITIALIZER:PsiClassInitializerStub\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      ANONYMOUS_CLASS:PsiClassStub[anonymous name=null fqn=null baseref=Iterable<String>]\n" +
            "        METHOD:PsiMethodStub[iterator:Iterator<String>]\n" +
            "          MODIFIER_LIST:PsiModifierListStub[mask=1]\n" +
@@ -355,7 +355,7 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[deprecatedA name=Foo fqn=Foo]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      ANNOTATION:PsiAnnotationStub[@Deprecated]\n" +
            "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "      ANNOTATION:PsiAnnotationStub[@SuppressWarnings(\"UnusedDeclaration\")]\n" +
@@ -388,7 +388,7 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "    IMPORT_STATEMENT:PsiImportStatementStub[j.u.C]\n" +
            "    IMPORT_STATEMENT:PsiImportStatementStub[j.u.D]\n" +
            "  CLASS:PsiClassStub[name=C fqn=C]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      TYPE_PARAMETER:PsiTypeParameter[T]\n" +
            "        ANNOTATION:PsiAnnotationStub[@A]\n" +
@@ -403,7 +403,7 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "      ANNOTATION:PsiAnnotationStub[@A]\n" +
            "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "    FIELD:PsiFieldStub[f:T<@A T1, @A ? extends @A T2>]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "        ANNOTATION:PsiAnnotationStub[@TA]\n" +
            "          ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "      ANNOTATION:PsiAnnotationStub[@A]\n" +
@@ -413,13 +413,13 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "      ANNOTATION:PsiAnnotationStub[@A]\n" +
            "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "    METHOD:PsiMethodStub[m:T]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "        ANNOTATION:PsiAnnotationStub[@TA]\n" +
            "          ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "        PARAMETER:PsiParameterStub[p:int]\n" +
-           "          MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "            ANNOTATION:PsiAnnotationStub[@TA]\n" +
            "              ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:@A E]\n" +
@@ -450,7 +450,7 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "      ANNOTATION:PsiAnnotationStub[@A9]\n" +
            "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
            "    METHOD:PsiMethodStub[v:int[][]]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      ANNOTATION:PsiAnnotationStub[@A]\n" +
            "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
@@ -470,17 +470,17 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "PsiJavaFileStub []\n" +
            "  IMPORT_LIST:PsiImportListStub\n" +
            "  CLASS:PsiClassStub[name=C fqn=C]\n" +
-           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
            "    METHOD:PsiMethodStub[m:void]\n" +
-           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "      PARAMETER_LIST:PsiParameterListStub\n" +
            "      THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n" +
            "      CLASS:PsiClassStub[name=L fqn=null]\n" +
-           "        MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "        MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
            "        TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "        EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
            "        IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n");
@@ -503,12 +503,12 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
     assertEquals("PsiJavaFileStub []\n" +
                  "  IMPORT_LIST:PsiImportListStub\n" +
                  "  CLASS:PsiClassStub[name=SOE_test fqn=SOE_test]\n" +
-                 "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+                 "    MODIFIER_LIST:PsiModifierListStub[mask=0]\n" +
                  "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
                  "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
                  "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n" +
                  "    FIELD:PsiFieldStub[BIG:BigInteger=;INITIALIZER_NOT_STORED;]\n" +
-                 "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n",
+                 "      MODIFIER_LIST:PsiModifierListStub[mask=0]\n",
                  DebugUtil.stubTreeToString(tree));
     System.out.println("SOE depth=" + i + ", time=" + t + "ms");
   }