Snapshot idea/138.1029 from git://git.jetbrains.org/idea/community.git

Update from idea/138.538 to idea/138.1029

Change-Id: I828f829a968439a99ec67640990c18ff7c9b58ce

15 files changed, 73 insertions, 35 deletions

diff --git a/java/java-psi-api/src/com/intellij/codeInsight/folding/JavaCodeFoldingSettings.java b/java/java-psi-api/src/com/intellij/codeInsight/folding/JavaCodeFoldingSettings.java
index 360b9832431d..5e45853f2f0f 100644
--- a/java/java-psi-api/src/com/intellij/codeInsight/folding/JavaCodeFoldingSettings.java
+++ b/java/java-psi-api/src/com/intellij/codeInsight/folding/JavaCodeFoldingSettings.java
@@ -64,4 +64,7 @@ public abstract class JavaCodeFoldingSettings {
 
   public abstract boolean isCollapseEndOfLineComments();
   public abstract void setCollapseEndOfLineComments(boolean value);
+
+  public abstract boolean isInlineParameterNamesForLiteralCallArguments();
+  public abstract void setInlineParameterNamesForLiteralCallArguments(boolean value);
 }
diff --git a/java/java-psi-api/src/com/intellij/psi/PsiIntersectionType.java b/java/java-psi-api/src/com/intellij/psi/PsiIntersectionType.java
index 55a5e9d55260..d1a1d7299d15 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiIntersectionType.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiIntersectionType.java
@@ -19,7 +19,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.util.Function;
-import gnu.trove.THashSet;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
@@ -52,7 +52,7 @@ public class PsiIntersectionType extends PsiType.Stub {
 
   private static PsiType[] flattenAndRemoveDuplicates(PsiType[] conjuncts) {
     try {
-      Set<PsiType> flattened = flatten(conjuncts, new THashSet<PsiType>());
+      Set<PsiType> flattened = flatten(conjuncts, ContainerUtil.<PsiType>newLinkedHashSet());
       return flattened.toArray(createArray(flattened.size()));
     }
     catch (NoSuchElementException e) {
diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
index 4c0e4be87185..fe45c66cf024 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
@@ -33,6 +33,7 @@ public class PsiMethodReferenceUtil {
 
   public static boolean hasReceiver(PsiType[] parameterTypes, QualifierResolveResult qualifierResolveResult, PsiMethodReferenceExpression methodRef) {
     if (parameterTypes.length > 0 && 
+        !methodRef.isConstructor() &&
         isReceiverType(parameterTypes[0], qualifierResolveResult.getContainingClass(), qualifierResolveResult.getSubstitutor()) &&
         isStaticallyReferenced(methodRef)) {
       return true;
diff --git a/java/java-psi-api/src/com/intellij/psi/PsiParameter.java b/java/java-psi-api/src/com/intellij/psi/PsiParameter.java
index dc8b0aefdabc..b7ad72a17c29 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiParameter.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiParameter.java
@@ -37,7 +37,7 @@ public interface PsiParameter extends PsiVariable {
   };
 
   /**
-   * Returns the element (method, foreach statement or catch block) in which the
+   * Returns the element (method, lambda expression, foreach statement or catch block) in which the
    * parameter is declared.
    *
    * @return the declaration scope for the parameter.
diff --git a/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java b/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java
index 917a88888d40..e7506ebd92fd 100644
--- a/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java
+++ b/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java
@@ -158,6 +158,7 @@ public class MethodCandidateInfo extends CandidateInfo{
     return level;
   }
 
+  @NotNull
   public PsiSubstitutor getSiteSubstitutor() {
     PsiSubstitutor incompleteSubstitutor = super.getSubstitutor();
     if (myTypeArguments != null) {
diff --git a/java/java-psi-api/src/com/intellij/psi/search/PackageScope.java b/java/java-psi-api/src/com/intellij/psi/search/PackageScope.java
index 19f72a8f91d5..a03f8849daa7 100644
--- a/java/java-psi-api/src/com/intellij/psi/search/PackageScope.java
+++ b/java/java-psi-api/src/com/intellij/psi/search/PackageScope.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -96,10 +96,12 @@ public class PackageScope extends GlobalSearchScope {
            ", includeSubpackages = " + myIncludeSubpackages;
   }
 
+  @NotNull
   public static GlobalSearchScope packageScope(@NotNull PsiPackage aPackage, boolean includeSubpackages) {
     return new PackageScope(aPackage, includeSubpackages, true);
   }
 
+  @NotNull
   public static GlobalSearchScope packageScopeWithoutLibraries(@NotNull PsiPackage aPackage, boolean includeSubpackages) {
     return new PackageScope(aPackage, includeSubpackages, false);
   }
diff --git a/java/java-psi-api/src/com/intellij/psi/search/searches/SuperMethodsSearch.java b/java/java-psi-api/src/com/intellij/psi/search/searches/SuperMethodsSearch.java
index 877094929876..dba92bebcb65 100644
--- a/java/java-psi-api/src/com/intellij/psi/search/searches/SuperMethodsSearch.java
+++ b/java/java-psi-api/src/com/intellij/psi/search/searches/SuperMethodsSearch.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -22,6 +22,7 @@ import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
 import com.intellij.psi.util.MethodSignatureUtil;
 import com.intellij.util.Query;
 import com.intellij.util.QueryExecutor;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -38,8 +39,8 @@ public class SuperMethodsSearch extends ExtensibleQueryFactory<MethodSignatureBa
     private final boolean myCheckBases;
     private final boolean myAllowStaticMethod;
 
-    public SearchParameters(final PsiMethod method,
-                            @Nullable final PsiClass aClass,
+    public SearchParameters(@NotNull PsiMethod method,
+                            @Nullable PsiClass aClass,
                             final boolean checkBases,
                             final boolean allowStaticMethod) {
       myCheckBases = checkBases;
@@ -52,6 +53,7 @@ public class SuperMethodsSearch extends ExtensibleQueryFactory<MethodSignatureBa
       return myCheckBases;
     }
 
+    @NotNull
     public final PsiMethod getMethod() {
       return myMethod;
     }
@@ -69,7 +71,11 @@ public class SuperMethodsSearch extends ExtensibleQueryFactory<MethodSignatureBa
   private SuperMethodsSearch() {
   }
 
-  public static Query<MethodSignatureBackedByPsiMethod> search(final PsiMethod derivedMethod, @Nullable final PsiClass psiClass, boolean checkBases, boolean allowStaticMethod) {
+  @NotNull
+  public static Query<MethodSignatureBackedByPsiMethod> search(@NotNull PsiMethod derivedMethod,
+                                                               @Nullable final PsiClass psiClass,
+                                                               boolean checkBases,
+                                                               boolean allowStaticMethod) {
     final SearchParameters parameters = new SearchParameters(derivedMethod, psiClass, checkBases, allowStaticMethod);
     return SUPER_METHODS_SEARCH_INSTANCE.createUniqueResultsQuery(parameters, MethodSignatureUtil.METHOD_BASED_HASHING_STRATEGY);
   }
diff --git a/java/java-psi-api/src/com/intellij/psi/util/IsConstantExpressionVisitor.java b/java/java-psi-api/src/com/intellij/psi/util/IsConstantExpressionVisitor.java
index 531edd732fae..be304ff5396f 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/IsConstantExpressionVisitor.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/IsConstantExpressionVisitor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -21,6 +21,8 @@ import gnu.trove.THashMap;
 
 import java.util.Map;
 
+import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING;
+
 public class IsConstantExpressionVisitor extends JavaElementVisitor {
   protected boolean myIsConstant;
   private final Map<PsiVariable, Boolean> varIsConst = new THashMap<PsiVariable, Boolean>();
@@ -63,7 +65,7 @@ public class IsConstantExpressionVisitor extends JavaElementVisitor {
     }
     PsiType type = element.getType();
     if (type instanceof PsiPrimitiveType) return;
-    if (type.equalsToText("java.lang.String")) return;
+    if (type.equalsToText(JAVA_LANG_STRING)) return;
     myIsConstant = false;
   }
 
@@ -88,7 +90,7 @@ public class IsConstantExpressionVisitor extends JavaElementVisitor {
       operand.accept(this);
       if (!myIsConstant) return;
       final PsiType type = operand.getType();
-      if (type != null && !(type instanceof PsiPrimitiveType) && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) {
+      if (type != null && !(type instanceof PsiPrimitiveType) && !type.equalsToText(JAVA_LANG_STRING)) {
         myIsConstant = false;
         return;
       }
diff --git a/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java b/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java
index adc9306ec962..5d11f1fb5005 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/MethodSignatureBackedByPsiMethod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -66,10 +66,12 @@ public class MethodSignatureBackedByPsiMethod extends MethodSignatureBase {
     return myMethod;
   }
 
+  @NotNull
   public static MethodSignatureBackedByPsiMethod create(@NotNull PsiMethod method, @NotNull PsiSubstitutor substitutor) {
     return create(method, substitutor, PsiUtil.isRawSubstitutor(method, substitutor));
   }
 
+  @NotNull
   public static MethodSignatureBackedByPsiMethod create(@NotNull PsiMethod method, @NotNull PsiSubstitutor substitutor, boolean isRaw) {
     PsiTypeParameter[] methodTypeParameters = method.getTypeParameters();
     if (isRaw) {
diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiConcatenationUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiConcatenationUtil.java
index feeb28037a5b..70c97495995b 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/PsiConcatenationUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/PsiConcatenationUtil.java
@@ -22,6 +22,8 @@ import com.intellij.util.IncorrectOperationException;
 
 import java.util.List;
 
+import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING;
+
 /**
  * User: cdr
  */
@@ -42,11 +44,11 @@ public class PsiConcatenationUtil {
       formatString.append(formatText);
     } else if (expression instanceof PsiPolyadicExpression) {
       final PsiType type = expression.getType();
-      if (type != null && type.equalsToText("java.lang.String")) {
+      if (type != null && type.equalsToText(JAVA_LANG_STRING)) {
         final PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression) expression;
         PsiExpression[] operands = binaryExpression.getOperands();
         PsiType left = operands[0].getType();
-        boolean stringStarted = left != null && left.equalsToText("java.lang.String");
+        boolean stringStarted = left != null && left.equalsToText(JAVA_LANG_STRING);
         if (stringStarted) {
           buildFormatString(operands[0], formatString, formatParameters, printfFormat);
         }
@@ -54,7 +56,7 @@ public class PsiConcatenationUtil {
           PsiExpression op = operands[i];
           PsiType optype = op.getType();
           PsiType r = TypeConversionUtil.calcTypeForBinaryExpression(left, optype, binaryExpression.getOperationTokenType(), true);
-          if (r != null && r.equalsToText("java.lang.String") && !stringStarted) {
+          if (r != null && r.equalsToText(JAVA_LANG_STRING) && !stringStarted) {
             stringStarted = true;
             PsiElement element = binaryExpression.getTokenBeforeOperand(op);
             if (element.getPrevSibling() instanceof PsiWhiteSpace) element = element.getPrevSibling();
@@ -64,7 +66,7 @@ public class PsiConcatenationUtil {
             addFormatParameter(subExpression, formatString, formatParameters, printfFormat);
           }
           if (stringStarted) {
-            if (optype != null && (optype.equalsToText("java.lang.String") || optype == PsiType.CHAR)) {
+            if (optype != null && (optype.equalsToText(JAVA_LANG_STRING) || optype == PsiType.CHAR)) {
               buildFormatString(op, formatString, formatParameters, printfFormat);
             }
             else {
diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
index c63a1373b00b..b71214f907f0 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
@@ -39,12 +39,15 @@ import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.EmptyIterable;
 import com.intellij.util.containers.HashMap;
 import gnu.trove.THashSet;
+import org.intellij.lang.annotations.MagicConstant;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 
+import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING;
+
 public final class PsiUtil extends PsiUtilCore {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.util.PsiUtil");
 
@@ -311,19 +314,18 @@ public final class PsiUtil extends PsiUtilCore {
     return false;
   }
 
+  @MagicConstant(intValues = {ACCESS_LEVEL_PUBLIC, ACCESS_LEVEL_PROTECTED, ACCESS_LEVEL_PACKAGE_LOCAL, ACCESS_LEVEL_PRIVATE})
   public static int getAccessLevel(@NotNull PsiModifierList modifierList) {
     if (modifierList.hasModifierProperty(PsiModifier.PRIVATE)) {
       return ACCESS_LEVEL_PRIVATE;
     }
-    else if (modifierList.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) {
+    if (modifierList.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) {
       return ACCESS_LEVEL_PACKAGE_LOCAL;
     }
-    else if (modifierList.hasModifierProperty(PsiModifier.PROTECTED)) {
+    if (modifierList.hasModifierProperty(PsiModifier.PROTECTED)) {
       return ACCESS_LEVEL_PROTECTED;
     }
-    else {
-      return ACCESS_LEVEL_PUBLIC;
-    }
+    return ACCESS_LEVEL_PUBLIC;
   }
 
   @PsiModifier.ModifierConstant
@@ -590,7 +592,7 @@ public final class PsiUtil extends PsiUtilCore {
    */
   public static boolean isCompileTimeConstant(@NotNull final PsiField field) {
     return field.hasModifierProperty(PsiModifier.FINAL)
-           && (TypeConversionUtil.isPrimitiveAndNotNull(field.getType()) || field.getType().equalsToText("java.lang.String"))
+           && (TypeConversionUtil.isPrimitiveAndNotNull(field.getType()) || field.getType().equalsToText(JAVA_LANG_STRING))
            && field.hasInitializer()
            && isConstantExpression(field.getInitializer());
   }
diff --git a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java
index 0fbfa4a059f9..d4382b40db7a 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java
@@ -504,8 +504,22 @@ public class RedundantCastUtil {
           return;
         }
         if (parent instanceof PsiForeachStatement) {
-          if (InheritanceUtil.isInheritor(PsiUtil.resolveClassInType(opType), false, CommonClassNames.JAVA_LANG_ITERABLE)) {
-            addToResults(typeCast);
+          final PsiClassType.ClassResolveResult castResolveResult = PsiUtil.resolveGenericsClassInType(opType);
+          final PsiClass psiClass = castResolveResult.getElement();
+          if (psiClass != null) {
+            final PsiClass iterableClass = JavaPsiFacade.getInstance(parent.getProject()).findClass(CommonClassNames.JAVA_LANG_ITERABLE, psiClass.getResolveScope());
+            if (iterableClass != null && InheritanceUtil.isInheritorOrSelf(psiClass, iterableClass, true)) {
+              final PsiTypeParameter[] iterableTypeParameters = iterableClass.getTypeParameters();
+              if (iterableTypeParameters.length == 1) {
+                final PsiType resultedParamType = TypeConversionUtil.getSuperClassSubstitutor(iterableClass, psiClass, castResolveResult.getSubstitutor()).substitute(iterableTypeParameters[0]);
+                if (resultedParamType != null && 
+                    TypeConversionUtil.isAssignable(((PsiForeachStatement)parent).getIterationParameter().getType(), resultedParamType)) {
+                  addToResults(typeCast);
+                  return;
+                }
+              }
+            } 
+          } else {
             return;
           }
         }
diff --git a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
index 5a793b9ef340..477a74e64b2e 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -40,6 +40,8 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
+import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING;
+
 public class TypeConversionUtil {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.util.TypeConversionUtil");
 
@@ -469,7 +471,7 @@ public class TypeConversionUtil {
 
     int rank = TYPE_TO_RANK_MAP.get(type);
     if (rank != 0) return rank;
-    if (type.equalsToText("java.lang.String")) return STRING_RANK;
+    if (type.equalsToText(JAVA_LANG_STRING)) return STRING_RANK;
     return Integer.MAX_VALUE;
   }
 
@@ -531,12 +533,12 @@ public class TypeConversionUtil {
       }
     }
     else if (tokenType == JavaTokenType.PLUS) {
-      if (ltype.equalsToText("java.lang.String")) {
+      if (ltype.equalsToText(JAVA_LANG_STRING)) {
         isApplicable = !isVoidType(rtype);
         resultTypeRank = STRING_RANK;
         break Label;
       }
-      else if (rtype.equalsToText("java.lang.String")) {
+      else if (rtype.equalsToText(JAVA_LANG_STRING)) {
         isApplicable = !isVoidType(ltype);
         resultTypeRank = STRING_RANK;
         break Label;
@@ -1370,7 +1372,7 @@ public class TypeConversionUtil {
   public static Object computeCastTo(final Object operand, final PsiType castType) {
     if (operand == null || castType == null) return null;
     Object value;
-    if (operand instanceof String && castType.equalsToText("java.lang.String")) {
+    if (operand instanceof String && castType.equalsToText(JAVA_LANG_STRING)) {
       value = operand;
     }
     else if (operand instanceof Boolean && PsiType.BOOLEAN.equals(castType)) {
@@ -1444,12 +1446,12 @@ public class TypeConversionUtil {
     if (sign == JavaTokenType.PLUS) {
       // evaluate right argument first, since '+-/*%' is left associative and left operand tends to be bigger
       if (rType == null) return null;
-      if (rType.equalsToText("java.lang.String")) {
+      if (rType.equalsToText(JAVA_LANG_STRING)) {
         return rType;
       }
       if (!accessLType) return NULL_TYPE;
       if (lType == null) return null;
-      if (lType.equalsToText("java.lang.String")) {
+      if (lType.equalsToText(JAVA_LANG_STRING)) {
         return lType;
       }
       return unboxAndBalanceTypes(lType, rType);
diff --git a/java/java-psi-api/src/com/intellij/psi/util/TypesDistinctProver.java b/java/java-psi-api/src/com/intellij/psi/util/TypesDistinctProver.java
index 81dda5863402..5e13c8f780fc 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/TypesDistinctProver.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/TypesDistinctProver.java
@@ -57,7 +57,7 @@ public class TypesDistinctProver {
           final PsiClass boundClass1 = PsiUtil.resolveClassInType(extendsBound);
           if (boundClass1 == null) return false;
 
-          if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass2.getQualifiedName())) {
+          if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass2.getQualifiedName()) && !(boundClass1 instanceof PsiTypeParameter)) {
             return !CommonClassNames.JAVA_LANG_OBJECT.equals(boundClass1.getQualifiedName());
           }
 
@@ -121,7 +121,7 @@ public class TypesDistinctProver {
           if (substitutedType1 instanceof PsiWildcardType && !((PsiWildcardType)substitutedType1).isBounded()) return true;
         }
       }
-      return false;
+      if (level < 2) return false;
     }
 
     final PsiClass boundClass1 = classResolveResult1.getElement();
diff --git a/java/java-psi-api/src/com/intellij/util/VisibilityIcons.java b/java/java-psi-api/src/com/intellij/util/VisibilityIcons.java
index 1988e63586a8..96d903a1a1b9 100644
--- a/java/java-psi-api/src/com/intellij/util/VisibilityIcons.java
+++ b/java/java-psi-api/src/com/intellij/util/VisibilityIcons.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -24,6 +24,7 @@ import com.intellij.psi.PsiModifierList;
 import com.intellij.psi.util.PsiUtil;
 import com.intellij.ui.RowIcon;
 import com.intellij.util.ui.EmptyIcon;
+import org.intellij.lang.annotations.MagicConstant;
 
 import javax.swing.*;
 
@@ -55,7 +56,7 @@ public class VisibilityIcons {
       }
   }
 
-  public static void setVisibilityIcon(int accessLevel, RowIcon baseIcon) {
+  public static void setVisibilityIcon(@MagicConstant(intValues = {PsiUtil.ACCESS_LEVEL_PUBLIC, PsiUtil.ACCESS_LEVEL_PROTECTED, PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL, PsiUtil.ACCESS_LEVEL_PRIVATE}) int accessLevel, RowIcon baseIcon) {
     Icon icon;
     switch (accessLevel) {
       case PsiUtil.ACCESS_LEVEL_PUBLIC: