[groovy] compute and cache modifiers once

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/api/auxiliary/modifiers/GrModifierList.java

@@ -23,6 +23,7 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifier.GrModifierConstant;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
 
 /**
@@ -31,11 +32,13 @@ import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.
  */
 public interface GrModifierList extends GroovyPsiElement, PsiModifierList {
 
+  int getModifierFlags();
+
   @NotNull
   PsiElement[] getModifiers();
 
   @Nullable
-  PsiElement getModifier(@GrModifier.GrModifierConstant @NotNull @NonNls String name);
+  PsiElement getModifier(@GrModifierConstant @NotNull @NonNls String name);
 
   boolean hasExplicitVisibilityModifiers();
 
@@ -44,13 +47,13 @@ public interface GrModifierList extends GroovyPsiElement, PsiModifierList {
   GrAnnotation[] getAnnotations();
 
   @Override
-  boolean hasModifierProperty(@GrModifier.GrModifierConstant @NotNull @NonNls String name);
+  boolean hasModifierProperty(@GrModifierConstant @NotNull @NonNls String name);
 
   @Override
-  boolean hasExplicitModifier(@GrModifier.GrModifierConstant @NotNull @NonNls String name);
+  boolean hasExplicitModifier(@GrModifierConstant @NotNull @NonNls String name);
 
   @Override
-  void setModifierProperty(@GrModifier.GrModifierConstant @NotNull @NonNls String name, boolean value) throws IncorrectOperationException;
+  void setModifierProperty(@GrModifierConstant @NotNull @NonNls String name, boolean value) throws IncorrectOperationException;
 
   @NotNull
   GrAnnotation[] getRawAnnotations();

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/modifiers/GrModifierListImpl.java

@@ -20,10 +20,9 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.*;
 import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.util.CachedValueProvider;
+import com.intellij.psi.util.CachedValueProvider.Result;
 import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.psi.util.PsiModificationTracker;
-import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.ArrayFactory;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.containers.ContainerUtil;
@@ -31,29 +30,20 @@ import gnu.trove.TObjectIntHashMap;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.plugins.groovy.config.GroovyConfigUtils;
 import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
 import org.jetbrains.plugins.groovy.lang.lexer.TokenSets;
 import org.jetbrains.plugins.groovy.lang.parser.GroovyElementTypes;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifier;
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifier.GrModifierConstant;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierFlags;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariable;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariableDeclaration;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinitionBody;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrEnumConstant;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
-import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.packaging.GrPackageDefinition;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GrStubElementBase;
 import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.GrModifierListStub;
-import org.jetbrains.plugins.groovy.lang.psi.util.GrTraitUtil;
 import org.jetbrains.plugins.groovy.lang.psi.util.PsiUtilKt;
 
 import java.util.ArrayList;
@@ -116,8 +106,6 @@ public class GrModifierListImpl extends GrStubElementBase<GrModifierListStub> im
     NAME_TO_MODIFIER_ELEMENT_TYPE.put(GrModifier.VOLATILE, GroovyTokenTypes.kVOLATILE);
   }
 
-  private static final String[] VISIBILITY_MODIFIERS = {GrModifier.PUBLIC, GrModifier.PROTECTED, GrModifier.PRIVATE};
-
   public GrModifierListImpl(@NotNull ASTNode node) {
     super(node);
   }
@@ -139,6 +127,23 @@ public class GrModifierListImpl extends GrStubElementBase<GrModifierListStub> im
     return "Modifiers";
   }
 
+  @Override
+  public int getModifierFlags() {
+    final GrModifierListStub stub = getGreenStub();
+    if (stub != null) {
+      return stub.getModifiersFlags();
+    }
+    else {
+      return CachedValuesManager.getCachedValue(this, () -> {
+        int flags = 0;
+        for (PsiElement modifier : findChildrenByType(TokenSets.MODIFIERS)) {
+          flags |= NAME_TO_MODIFIER_FLAG_MAP.get(modifier.getText());
+        }
+        return Result.create(flags, this);
+      });
+    }
+  }
+
   @Override
   @NotNull
   public PsiElement[] getModifiers() {
@@ -154,119 +159,23 @@ public class GrModifierListImpl extends GrStubElementBase<GrModifierListStub> im
 
   @Nullable
   @Override
-  public PsiElement getModifier(@GrModifier.GrModifierConstant @NotNull @NonNls String name) {
+  public PsiElement getModifier(@GrModifierConstant @NotNull @NonNls String name) {
     return findChildByType(NAME_TO_MODIFIER_ELEMENT_TYPE.get(name));
   }
 
   @Override
   public boolean hasExplicitVisibilityModifiers() {
-    final GrModifierListStub stub = getStub();
-    if (stub != null) {
-      return (stub.getModifiersFlags() & (GrModifierFlags.PUBLIC_MASK | GrModifierFlags.PROTECTED_MASK | GrModifierFlags.PRIVATE_MASK)) != 0;
-    }
-
-    for (@GrModifier.GrModifierConstant String type : VISIBILITY_MODIFIERS) {
-      if (hasExplicitModifier(type)) return true;
-    }
-    return false;
-  }
-
-  public static boolean checkModifierProperty(@NotNull GrModifierList modifierList, @GrModifier.GrModifierConstant @NotNull String modifier) {
-    final PsiElement owner = modifierList.getParent();
-    PsiElement parent = PsiTreeUtil.getStubOrPsiParent(owner);
-    if (owner instanceof GrVariableDeclaration && parent instanceof GrTypeDefinitionBody) {
-      PsiElement pParent = parent.getParent();
-      if (!modifierList.hasExplicitVisibilityModifiers()) { //properties are backed by private fields
-        if (!(pParent instanceof GrTypeDefinition && GrTraitUtil.isInterface((GrTypeDefinition)pParent))) {
-          if (modifier.equals(GrModifier.PRIVATE)) return true;
-          if (modifier.equals(GrModifier.PROTECTED)) return false;
-          if (modifier.equals(GrModifier.PUBLIC)) return false;
-        }
-      }
-
-      if (pParent instanceof GrTypeDefinition && GrTraitUtil.isInterface((GrTypeDefinition)pParent)) {
-        if (modifier.equals(GrModifier.STATIC)) return true;
-        if (modifier.equals(GrModifier.FINAL)) return true;
-      }
-      if (pParent instanceof GrTypeDefinition && modifier.equals(GrModifier.FINAL) && !modifierList.hasExplicitVisibilityModifiers()) {
-        PsiModifierList pModifierList = ((GrTypeDefinition)pParent).getModifierList();
-        if (pModifierList != null && PsiImplUtil.hasImmutableAnnotation(pModifierList)) {
-          return true;
-        }
-      }
-    }
-
-    if (owner instanceof GrMethod && parent instanceof GrTypeDefinitionBody) {
-      PsiElement pParent = parent.getParent();
-      if (pParent instanceof GrTypeDefinition && ((GrTypeDefinition)pParent).isInterface()) {
-        if (GrModifier.ABSTRACT.equals(modifier)) return true;
-        if (!((GrTypeDefinition)pParent).isTrait() && GrModifier.PUBLIC.equals(modifier)) return true;
-      }
-    }
-
-    if (modifierList.hasExplicitModifier(modifier)) {
-      return true;
-    }
-
-    if (modifier.equals(GrModifier.PUBLIC)) {
-      if (owner instanceof GrPackageDefinition) return false;
-      if (owner instanceof GrVariableDeclaration && !(parent instanceof GrTypeDefinitionBody) || owner instanceof GrVariable) {
-        return false;
-      }
-      //groovy type definitions and methods are public by default
-      return !modifierList.hasExplicitModifier(GrModifier.PRIVATE) && !modifierList.hasExplicitModifier(GrModifier.PROTECTED);
-    }
-
-    if (owner instanceof GrTypeDefinition) {
-      final GrTypeDefinition clazz = (GrTypeDefinition)owner;
-
-      if (modifier.equals(GrModifier.STATIC)) {
-        final PsiClass containingClass = clazz.getContainingClass();
-        return GrTraitUtil.isInterface(containingClass);
-      }
-      if (modifier.equals(GrModifier.ABSTRACT)) {
-        if (clazz.isInterface()) return true;
-        if (clazz.isEnum() &&
-            GroovyConfigUtils.getInstance().isVersionAtLeast(modifierList, GroovyConfigUtils.GROOVY2_0)) {
-          for (GrMethod method : clazz.getCodeMethods()) {
-            if (method.hasModifierProperty(PsiModifier.ABSTRACT)) return true;
-          }
-        }
-      }
-      if (modifier.equals(GrModifier.FINAL)) {
-        if (clazz.isEnum()) {
-          final GrField[] fields = clazz.getFields();
-          for (GrField field : fields) {
-            if (field instanceof GrEnumConstant && ((GrEnumConstant)field).getInitializingClass() != null) {
-              return false;
-            }
-          }
-          return true;
-        }
-      }
-    }
-
-    return false;
+    return GrModifierListUtil.hasExplicitVisibilityModifiers(this);
   }
 
   @Override
-  public boolean hasModifierProperty(@NotNull @NonNls String modifier) {
-    return checkModifierProperty(this, modifier);
+  public boolean hasModifierProperty(@NotNull String name) {
+    return GrModifierListUtil.hasModifierProperty(this, name);
   }
 
   @Override
-  public boolean hasExplicitModifier(@NotNull @NonNls String name) {
-    final GrModifierListStub stub = getStub();
-    if (stub != null) {
-      return hasMaskExplicitModifier(name, stub.getModifiersFlags());
-    }
-
-    return getModifier(name) != null;
-  }
-
-  public static boolean hasMaskExplicitModifier(String name, int mask) {
-    final int flag = NAME_TO_MODIFIER_FLAG_MAP.get(name);
-    return (mask & flag) != 0;
+  public boolean hasExplicitModifier(@NotNull String name) {
+    return GrModifierListUtil.hasExplicitModifier(this, name);
   }
 
   @Override
@@ -371,9 +280,10 @@ public class GrModifierListImpl extends GrStubElementBase<GrModifierListStub> im
   @Override
   @NotNull
   public GrAnnotation[] getAnnotations() {
-    return CachedValuesManager.getCachedValue(this,
-                                              () -> CachedValueProvider.Result
-                                                .create(GrAnnotationCollector.getResolvedAnnotations(this), PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT));
+    return CachedValuesManager.getCachedValue(this, () -> Result.create(
+      GrAnnotationCollector.getResolvedAnnotations(this),
+      PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT
+    ));
   }
 
   @Override

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/modifiers/modifiers.kt

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+@file:JvmName("GrModifierListUtil")
+
+package org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers
+
+import com.intellij.psi.PsiModifier
+import com.intellij.psi.util.CachedValueProvider.Result
+import com.intellij.psi.util.CachedValuesManager
+import com.intellij.psi.util.PsiModificationTracker
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.annotations.NonNls
+import org.jetbrains.plugins.groovy.config.GroovyConfigUtils
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifier.GrModifierConstant
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierFlags.*
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariableDeclaration
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinitionBody
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrEnumConstant
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod
+import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil
+import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP
+import org.jetbrains.plugins.groovy.lang.psi.util.GrTraitUtil
+
+private val explicitVisibilityModifiers = PUBLIC_MASK or PRIVATE_MASK or PROTECTED_MASK
+
+fun Int.hasMaskModifier(@GrModifierConstant @NonNls name: String): Boolean {
+  return and(NAME_TO_MODIFIER_FLAG_MAP[name]) != 0
+}
+
+internal fun GrModifierList.hasExplicitVisibilityModifiers(): Boolean {
+  return explicitVisibilityModifiers and modifierFlags != 0
+}
+
+internal fun GrModifierList.hasExplicitModifier(@GrModifierConstant @NonNls name: String): Boolean {
+  return modifierFlags.hasMaskModifier(name)
+}
+
+internal fun GrModifierList.hasModifierProperty(@GrModifierConstant @NonNls name: String): Boolean {
+  return getAllModifierFlags().hasMaskModifier(name)
+}
+
+internal fun GrModifierList.getAllModifierFlags(): Int = CachedValuesManager.getCachedValue(this) {
+  Result.create(doGetModifierFlags(), if (isPhysical) this else PsiModificationTracker.MODIFICATION_COUNT)
+}
+
+private fun GrModifierList.doGetModifierFlags(): Int {
+  return modifierFlags or parent.let { owner ->
+    if (owner is GrTypeDefinition) {
+      doGetTypeDefinitionFlags(owner, this)
+    }
+    else {
+      val parent = PsiTreeUtil.getStubOrPsiParent(owner) as? GrTypeDefinitionBody
+      val containingClass = parent?.parent as? GrTypeDefinition
+      when (owner) {
+        is GrMethod -> doGetMethodFlags(containingClass, this)
+        is GrVariableDeclaration -> doGetVariableModifierMask(containingClass, this)
+        else -> 0
+      }
+    }
+  }
+}
+
+private fun doGetTypeDefinitionFlags(clazz: GrTypeDefinition, modifierList: GrModifierList): Int {
+  var flags = 0
+
+  if (clazz.isInterface) {
+    flags = flags or ABSTRACT_MASK
+  }
+  else if (clazz.isEnum) {
+    if (GroovyConfigUtils.getInstance().isVersionAtLeast(modifierList, GroovyConfigUtils.GROOVY2_0)) {
+      if (clazz.codeMethods.any { it.hasModifierProperty(PsiModifier.ABSTRACT) }) {
+        flags = flags or ABSTRACT_MASK
+      }
+    }
+    if (clazz.codeFields.none { it is GrEnumConstant && it.initializingClass != null }) {
+      flags = flags or FINAL_MASK
+    }
+  }
+
+  val containingClass = clazz.containingClass
+  if (GrTraitUtil.isInterface(containingClass)) {
+    flags = flags or STATIC_MASK
+  }
+
+  if (!modifierList.hasExplicitVisibilityModifiers()) {
+    flags = flags or PUBLIC_MASK
+  }
+
+  return flags
+}
+
+private fun doGetMethodFlags(clazz: GrTypeDefinition?, modifierList: GrModifierList): Int {
+  var flags = 0
+
+  if (clazz != null) {
+    if (clazz.isInterface) flags = flags or ABSTRACT_MASK // groovy interface or trait
+    if (GrTraitUtil.isInterface(clazz)) flags = flags or PUBLIC_MASK // groovy interface
+  }
+
+  if (!modifierList.hasExplicitVisibilityModifiers()) {
+    flags = flags or PUBLIC_MASK
+  }
+
+  return flags
+}
+
+private fun doGetVariableModifierMask(clazz: GrTypeDefinition?, modifierList: GrModifierList): Int {
+  var flags = 0
+
+  if (clazz != null) {
+    if (GrTraitUtil.isInterface(clazz)) {
+      flags = flags or STATIC_MASK or FINAL_MASK or PUBLIC_MASK
+    }
+    else if (!modifierList.hasExplicitVisibilityModifiers()) {
+      flags = flags or PRIVATE_MASK
+      if (clazz.modifierList?.let { PsiImplUtil.hasImmutableAnnotation(it) } == true) {
+        flags = flags or FINAL_MASK
+      }
+    }
+  }
+
+  return flags
+}

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightModifierList.java

@@ -16,7 +16,6 @@
 package org.jetbrains.plugins.groovy.lang.psi.impl.synthetic;
 
 import com.intellij.psi.*;
-import com.intellij.psi.impl.cache.ModifierFlags;
 import com.intellij.psi.impl.light.LightElement;
 import com.intellij.util.IncorrectOperationException;
 import org.intellij.lang.annotations.MagicConstant;
@@ -28,11 +27,13 @@ import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifier;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierFlags;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
-import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListImpl;
+import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListUtil;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP;
+
 public class GrLightModifierList extends LightElement implements GrModifierList {
 
   private int myModifiers;
@@ -50,8 +51,13 @@ public class GrLightModifierList extends LightElement implements GrModifierList
     return myParent;
   }
 
+  @Override
+  public PsiFile getContainingFile() {
+    return getParent().getContainingFile();
+  }
+
   public void addModifier(String modifier) {
-    int code = GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP.get(modifier);
+    int code = NAME_TO_MODIFIER_FLAG_MAP.get(modifier);
     assert code != 0;
     myModifiers |= code;
   }
@@ -76,22 +82,23 @@ public class GrLightModifierList extends LightElement implements GrModifierList
     }
   }
 
-  public int getModifiersAsInt() {
+  @Override
+  public int getModifierFlags() {
     return myModifiers;
   }
-  
+
   @Override
-  public boolean hasModifierProperty(@NotNull String name){
-    return GrModifierListImpl.checkModifierProperty(this, name);
+  public boolean hasModifierProperty(@NotNull String name) {
+    return GrModifierListUtil.hasModifierProperty(this, name);
   }
 
   @Override
   public boolean hasExplicitModifier(@NotNull String name) {
-    return (myModifiers & GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP.get(name)) != 0;
+    return GrModifierListUtil.hasExplicitModifier(this, name);
   }
 
   @Override
-  public void setModifierProperty(@NotNull String name, boolean value) throws IncorrectOperationException{
+  public void setModifierProperty(@NotNull String name, boolean value) throws IncorrectOperationException {
     throw new IncorrectOperationException();
   }
 
@@ -102,7 +109,7 @@ public class GrLightModifierList extends LightElement implements GrModifierList
   }
 
   @Override
-  public void checkSetModifierProperty(@NotNull String name, boolean value) throws IncorrectOperationException{
+  public void checkSetModifierProperty(@NotNull String name, boolean value) throws IncorrectOperationException {
     throw new IncorrectOperationException();
   }
 
@@ -180,7 +187,7 @@ public class GrLightModifierList extends LightElement implements GrModifierList
 
   @Override
   public boolean hasExplicitVisibilityModifiers() {
-    return (myModifiers & (GrModifierFlags.PUBLIC_MASK | GrModifierFlags.PRIVATE_MASK | GrModifierFlags.PROTECTED_MASK)) != 0;
+    return GrModifierListUtil.hasExplicitVisibilityModifiers(this);
   }
 
   @Override
@@ -192,26 +199,23 @@ public class GrLightModifierList extends LightElement implements GrModifierList
   public void acceptChildren(GroovyElementVisitor visitor) {
 
   }
-  
+
   public void copyModifiers(@NotNull PsiModifierListOwner modifierOwner) {
     int mod = 0;
 
     PsiModifierList modifierList = modifierOwner.getModifierList();
-    if (modifierList != null) {
-      if (modifierList instanceof GrLightModifierList) {
-        mod = ((GrLightModifierList)modifierList).getModifiersAsInt();
-      }
-      else {
-        for (Object o : ModifierFlags.NAME_TO_MODIFIER_FLAG_MAP.keys()) {
-          String modifier = (String)o;
-          if (modifierList.hasExplicitModifier(modifier)) {
-            mod |= GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP.get(modifier);
-          }
+
+    if (modifierList instanceof GrModifierList) {
+      mod = ((GrModifierList)modifierList).getModifierFlags();
+    }
+    else if (modifierList != null) {
+      for (String modifier : PsiModifier.MODIFIERS) {
+        if (modifierList.hasExplicitModifier(modifier)) {
+          mod |= NAME_TO_MODIFIER_FLAG_MAP.get(modifier);
         }
       }
     }
 
     setModifiers(mod);
   }
-  
 }

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/stubs/GrModifierListStub.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,10 +18,8 @@ package org.jetbrains.plugins.groovy.lang.psi.stubs;
 import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.stubs.StubBase;
 import com.intellij.psi.stubs.StubElement;
-import gnu.trove.TObjectIntIterator;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
-import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListImpl;
 
 /**
  * @author Maxim.Medvedev
@@ -37,17 +35,4 @@ public class GrModifierListStub extends StubBase<GrModifierList> implements Stub
   public int getModifiersFlags() {
     return myFlags;
   }
-
-  public static int buildFlags(GrModifierList modifierList) {
-    int flags = 0;
-    final TObjectIntIterator<String> iterator = GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP.iterator();
-    while (iterator.hasNext()) {
-      iterator.advance();
-      if (modifierList.hasExplicitModifier(iterator.key())) {
-        flags |= iterator.value();
-      }
-    }
-    return flags;
-  }
-
 }

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/stubs/GrStubUtils.java

@@ -38,13 +38,14 @@ import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrAnonymousC
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
 import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.imports.GrImportStatement;
 import org.jetbrains.plugins.groovy.lang.psi.api.types.GrTypeElement;
-import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListImpl;
 
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import static org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrModifierListUtil.hasMaskModifier;
+
 /**
  * User: Dmitry.Krasilschikov
  * Date: 02.06.2009
@@ -153,10 +154,10 @@ public class GrStubUtils {
       return false;
     }
     int mask = ((GrModifierListStub)type).getModifiersFlags();
-    if (GrModifierListImpl.hasMaskExplicitModifier(PsiModifier.PRIVATE, mask)) {
+    if (hasMaskModifier(mask, PsiModifier.PRIVATE)) {
       return false;
     }
-    if (GrModifierListImpl.hasMaskExplicitModifier(PsiModifier.STATIC, mask)) {
+    if (hasMaskModifier(mask, PsiModifier.STATIC)) {
       return true;
     }
 

plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/stubs/elements/GrModifierListElementType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42,7 +42,7 @@ public class GrModifierListElementType extends GrStubElementType<GrModifierListS
   @NotNull
   @Override
   public GrModifierListStub createStub(@NotNull GrModifierList psi, StubElement parentStub) {
-    return new GrModifierListStub(parentStub, GroovyElementTypes.MODIFIERS, GrModifierListStub.buildFlags(psi));
+    return new GrModifierListStub(parentStub, GroovyElementTypes.MODIFIERS, psi.getModifierFlags());
   }
 
   @Override