[jvm-lang] implement #hasModifier via #hasModifierProperty

java/java-psi-api/src/com/intellij/lang/jvm/JvmModifiersOwner.java

@@ -1,24 +1,8 @@
-/*
- * Copyright 2000-2017 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.
- */
+// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.lang.jvm;
 
 import org.jetbrains.annotations.NotNull;
 
-import static com.intellij.util.ArrayUtil.contains;
-
 /**
  * Represents an element which has modifiers and annotations.
  */
@@ -33,7 +17,5 @@ public interface JvmModifiersOwner extends JvmAnnotatedElement {
    * @param modifier the modifier to check
    * @return true if the element has the modifier, false otherwise
    */
-  default boolean hasModifier(@NotNull JvmModifier modifier) {
-    return contains(modifier, getModifiers());
-  }
+  boolean hasModifier(@NotNull JvmModifier modifier);
 }

java/java-psi-api/src/com/intellij/psi/PsiJvmConversionHelper.java

@@ -5,13 +5,10 @@ import com.intellij.lang.jvm.JvmClassKind;
 import com.intellij.lang.jvm.JvmModifier;
 import com.intellij.lang.jvm.types.JvmReferenceType;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.EnumSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 import static com.intellij.psi.PsiType.getJavaLangObject;
 import static com.intellij.psi.PsiType.getTypeByName;
@@ -19,21 +16,25 @@ import static com.intellij.psi.PsiType.getTypeByName;
 class PsiJvmConversionHelper {
 
   private static final Logger LOG = Logger.getInstance(PsiJvmConversionHelper.class);
-  private static final Map<String, JvmModifier> MODIFIERS = ContainerUtil.<String, JvmModifier>immutableMapBuilder()
-    .put(PsiModifier.PUBLIC, JvmModifier.PUBLIC)
-    .put(PsiModifier.PROTECTED, JvmModifier.PROTECTED)
-    .put(PsiModifier.PRIVATE, JvmModifier.PRIVATE)
-    .put(PsiModifier.PACKAGE_LOCAL, JvmModifier.PACKAGE_LOCAL)
-    .put(PsiModifier.STATIC, JvmModifier.STATIC)
-    .put(PsiModifier.ABSTRACT, JvmModifier.ABSTRACT)
-    .put(PsiModifier.FINAL, JvmModifier.FINAL)
-    .put(PsiModifier.NATIVE, JvmModifier.NATIVE)
-    .put(PsiModifier.SYNCHRONIZED, JvmModifier.SYNCHRONIZED)
-    .put(PsiModifier.STRICTFP, JvmModifier.STRICTFP)
-    .put(PsiModifier.TRANSIENT, JvmModifier.TRANSIENT)
-    .put(PsiModifier.VOLATILE, JvmModifier.VOLATILE)
-    .put(PsiModifier.TRANSITIVE, JvmModifier.TRANSITIVE)
-    .build();
+  private static final Map<JvmModifier, String> MODIFIERS;
+
+  static {
+    Map<JvmModifier, String> modifiers = new EnumMap<>(JvmModifier.class);
+    modifiers.put(JvmModifier.PUBLIC, PsiModifier.PUBLIC);
+    modifiers.put(JvmModifier.PROTECTED, PsiModifier.PROTECTED);
+    modifiers.put(JvmModifier.PRIVATE, PsiModifier.PRIVATE);
+    modifiers.put(JvmModifier.PACKAGE_LOCAL, PsiModifier.PACKAGE_LOCAL);
+    modifiers.put(JvmModifier.STATIC, PsiModifier.STATIC);
+    modifiers.put(JvmModifier.ABSTRACT, PsiModifier.ABSTRACT);
+    modifiers.put(JvmModifier.FINAL, PsiModifier.FINAL);
+    modifiers.put(JvmModifier.NATIVE, PsiModifier.NATIVE);
+    modifiers.put(JvmModifier.SYNCHRONIZED, PsiModifier.SYNCHRONIZED);
+    modifiers.put(JvmModifier.STRICTFP, PsiModifier.STRICTFP);
+    modifiers.put(JvmModifier.TRANSIENT, PsiModifier.TRANSIENT);
+    modifiers.put(JvmModifier.VOLATILE, PsiModifier.VOLATILE);
+    modifiers.put(JvmModifier.TRANSITIVE, PsiModifier.TRANSITIVE);
+    MODIFIERS = Collections.unmodifiableMap(modifiers);
+  }
 
   @NotNull
   static PsiAnnotation[] getListAnnotations(@NotNull PsiModifierListOwner modifierListOwner) {
@@ -55,7 +56,7 @@ class PsiJvmConversionHelper {
   @NotNull
   static JvmModifier[] getListModifiers(@NotNull PsiModifierListOwner modifierListOwner) {
     final Set<JvmModifier> result = EnumSet.noneOf(JvmModifier.class);
-    MODIFIERS.forEach((psi, jvm) -> {
+    MODIFIERS.forEach((jvm, psi) -> {
       if (modifierListOwner.hasModifierProperty(psi)) {
         result.add(jvm);
       }
@@ -63,6 +64,10 @@ class PsiJvmConversionHelper {
     return result.toArray(JvmModifier.EMPTY_ARRAY);
   }
 
+  static boolean hasListModifier(@NotNull PsiModifierListOwner modifierListOwner, @NotNull JvmModifier modifier) {
+    return modifierListOwner.hasModifierProperty(MODIFIERS.get(modifier));
+  }
+
   @NotNull
   static JvmClassKind getJvmClassKind(@NotNull PsiClass psiClass) {
     if (psiClass.isAnnotationType()) return JvmClassKind.ANNOTATION;

java/java-psi-api/src/com/intellij/psi/PsiModifierListOwner.java

@@ -55,6 +55,11 @@ public interface PsiModifierListOwner extends PsiElement, JvmModifiersOwner {
     return getListModifiers(this);
   }
 
+  @Override
+  default boolean hasModifier(@NotNull JvmModifier modifier) {
+    return hasListModifier(this, modifier);
+  }
+
   @Nullable
   @Override
   default PsiElement getSourceElement() {