diff --git a/java/java-psi-api/src/com/intellij/psi/augment/PsiAugmentProvider.java b/java/java-psi-api/src/com/intellij/psi/augment/PsiAugmentProvider.java index 532dda378f07..a3074e72a3a0 100644 --- a/java/java-psi-api/src/com/intellij/psi/augment/PsiAugmentProvider.java +++ b/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 transformModifiers(@NotNull PsiModifierList modifierList, @NotNull final Set modifiers) { + return modifiers; } // @@ -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 result = Ref.create(); + @NotNull + public static Set transformModifierProperties(@NotNull final PsiModifierList modifierList, + @NotNull Project project, + @NotNull final Set modifiers) { + final Ref> result = Ref.create(modifiers); - forEach(modifierList.getProject(), new Processor() { + forEach(project, new Processor() { @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; } }); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/cache/ModifierFlags.java b/java/java-psi-impl/src/com/intellij/psi/impl/cache/ModifierFlags.java index 02b9bf5b4f2a..fc3436d00a60 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/cache/ModifierFlags.java +++ b/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 NAME_TO_MODIFIER_FLAG_MAP = new TObjectIntHashMap(); + public static final TIntObjectHashMap MODIFIER_FLAG_TO_NAME_MAP = new TIntObjectHashMap(); public static final TObjectIntHashMap KEYWORD_TO_MODIFIER_FLAG_MAP = new TObjectIntHashMap(); 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); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java index 65e2e9554ca0..2fad212ae794 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java +++ b/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 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 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(); } } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaModifierListElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaModifierListElementType.java index 6f9e9f0e66ed..7b5e844213c4 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaModifierListElementType.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaModifierListElementType.java @@ -60,7 +60,7 @@ public class JavaModifierListElementType extends JavaStubElementType { - public static final int STUB_VERSION = 23; + public static final int STUB_VERSION = 24; public JavaFileElementType() { super("java.FILE", JavaLanguage.INSTANCE); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java index 1d486c9dd58d..bd6a6e26538a 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java +++ b/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 implements PsiModifierList { private static final Map NAME_TO_KEYWORD_TYPE_MAP; + private static final Map KEYWORD_TYPE_TO_NAME_MAP; static { NAME_TO_KEYWORD_TYPE_MAP = new THashMap(); - 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 @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 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 calcExplicitModifiers() { + Set 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 calcImplicitModifiers(Set explicitModifiers) { + Set 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() { + @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 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 public String toString(){ return "PsiModifierList:" + getText(); } + + private static class ModifierCache { + static final WeakInterner> ourInterner = new WeakInterner>(); + final PsiFile file; + final List modifiers; + final long modCount; + + ModifierCache(@NotNull PsiFile file, @NotNull Set modifiers) { + this.file = file; + List 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; + } + } } \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/PsiAugmentProviderTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/PsiAugmentProviderTest.java index dbe333d6d074..801672bfe5f9 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/PsiAugmentProviderTest.java +++ b/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 transformModifiers(@NotNull PsiModifierList modifierList, @NotNull final Set modifiers) { + if (isLombokVal(modifierList.getParent())) { + THashSet result = ContainerUtil.newTroveSet(modifiers); + result.add(PsiModifier.FINAL); + return result; + } + return modifiers; } private static boolean isLombokVal(PsiElement variable) { diff --git a/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java b/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java index 5fe0a6529f7a..98061cca29a5 100644 --- a/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java +++ b/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]\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]\n" + " METHOD:PsiMethodStub[iterator:Iterator]\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"); }