From 21c6bce697e95c0e69c6afc4c8f637a4a05ed4ac Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Tue, 5 Mar 2013 14:20:16 +0400 Subject: [PATCH] cleanup --- .../daemon/impl/RefCountHolder.java | 17 ++++++++--------- .../util/containers/BidirectionalMap.java | 18 +++++++++++++++++- 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/RefCountHolder.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/RefCountHolder.java index 47456217955b..f0ac84d94ab3 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/RefCountHolder.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/RefCountHolder.java @@ -26,7 +26,7 @@ import com.intellij.psi.util.PsiMatcherImpl; import com.intellij.psi.util.PsiMatchers; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; -import com.intellij.util.ArrayUtil; +import com.intellij.util.ArrayUtilRt; import com.intellij.util.containers.BidirectionalMap; import com.intellij.util.containers.ConcurrentHashMap; import org.jetbrains.annotations.NonNls; @@ -34,6 +34,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.lang.ref.SoftReference; +import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.Map; @@ -47,7 +48,6 @@ public class RefCountHolder { private final Map myDclsUsedMap = new ConcurrentHashMap(); private final Map myImportStatements = new ConcurrentHashMap(); - private final Map myPossiblyDuplicateElements = new ConcurrentHashMap(); private final AtomicReference myState = new AtomicReference(VIRGIN); private static final ProgressIndicator VIRGIN = new DaemonProgressIndicator(); // just created or cleared private static final ProgressIndicator READY = new DaemonProgressIndicator(); @@ -124,7 +124,6 @@ public class RefCountHolder { } myImportStatements.clear(); myDclsUsedMap.clear(); - myPossiblyDuplicateElements.clear(); } public void registerLocallyReferenced(@NotNull PsiNamedElement result) { @@ -181,16 +180,16 @@ public class RefCountHolder { } } removeInvalidFrom(myDclsUsedMap.keySet()); - removeInvalidFrom(myPossiblyDuplicateElements.keySet()); } - private static void removeInvalidFrom(Iterable collection) { + + private static void removeInvalidFrom(@NotNull Collection collection) { for (Iterator it = collection.iterator(); it.hasNext();) { PsiElement element = it.next(); if (!element.isValid()) it.remove(); } } - public boolean isReferenced(PsiNamedElement element) { + public boolean isReferenced(@NotNull PsiNamedElement element) { List array; synchronized (myLocalRefsMap) { array = myLocalRefsMap.getKeysByValue(element); @@ -201,13 +200,13 @@ public class RefCountHolder { return usedStatus == Boolean.TRUE; } - private static boolean isParameterUsedRecursively(final PsiElement element, final List array) { + private static boolean isParameterUsedRecursively(@NotNull PsiElement element, @NotNull List array) { if (!(element instanceof PsiParameter)) return false; PsiParameter parameter = (PsiParameter)element; PsiElement scope = parameter.getDeclarationScope(); if (!(scope instanceof PsiMethod)) return false; PsiMethod method = (PsiMethod)scope; - int paramIndex = ArrayUtil.find(method.getParameterList().getParameters(), parameter); + int paramIndex = ArrayUtilRt.find(method.getParameterList().getParameters(), parameter); for (PsiReference reference : array) { if (!(reference instanceof PsiElement)) return false; @@ -223,7 +222,7 @@ public class RefCountHolder { if (method != methodExpression.resolve()) return false; PsiExpressionList argumentList = methodCallExpression.getArgumentList(); PsiExpression[] arguments = argumentList.getExpressions(); - int argumentIndex = ArrayUtil.find(arguments, argument); + int argumentIndex = ArrayUtilRt.find(arguments, argument); if (paramIndex != argumentIndex) return false; } diff --git a/platform/util/src/com/intellij/util/containers/BidirectionalMap.java b/platform/util/src/com/intellij/util/containers/BidirectionalMap.java index 8b404cd4555d..dc6db8184f1e 100644 --- a/platform/util/src/com/intellij/util/containers/BidirectionalMap.java +++ b/platform/util/src/com/intellij/util/containers/BidirectionalMap.java @@ -16,6 +16,7 @@ package com.intellij.util.containers; import gnu.trove.THashMap; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.*; @@ -24,6 +25,7 @@ public class BidirectionalMap implements Map{ private final Map myKeyToValueMap = new THashMap(); private final Map> myValueToKeysMap = new THashMap>(); + @Override public V put(K key, V value){ V oldValue = myKeyToValueMap.put(key, value); if (oldValue != null){ @@ -41,6 +43,7 @@ public class BidirectionalMap implements Map{ return oldValue; } + @Override public void clear() { myKeyToValueMap.clear(); myValueToKeysMap.clear(); @@ -51,27 +54,34 @@ public class BidirectionalMap implements Map{ return myValueToKeysMap.get(value); } + @NotNull + @Override public Set keySet() { return myKeyToValueMap.keySet(); } + @Override public int size(){ return myKeyToValueMap.size(); } + @Override public boolean isEmpty(){ return myKeyToValueMap.isEmpty(); } + @Override public boolean containsKey(Object key){ return myKeyToValueMap.containsKey(key); } + @Override @SuppressWarnings({"SuspiciousMethodCalls"}) public boolean containsValue(Object value){ return myValueToKeysMap.containsKey(value); } + @Override public V get(Object key) { return myKeyToValueMap.get(key); } @@ -85,6 +95,7 @@ public class BidirectionalMap implements Map{ } } + @Override @SuppressWarnings({"SuspiciousMethodCalls"}) public V remove(Object key){ final V value = myKeyToValueMap.remove(key); @@ -96,16 +107,21 @@ public class BidirectionalMap implements Map{ return value; } - public void putAll(Map t){ + @Override + public void putAll(@NotNull Map t){ for (final K k1 : t.keySet()) { put(k1, t.get(k1)); } } + @NotNull + @Override public Collection values(){ return myValueToKeysMap.keySet(); } + @NotNull + @Override public Set> entrySet(){ return myKeyToValueMap.entrySet(); }