diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java index dd55d137604e..f288180aa1fc 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java @@ -2014,18 +2014,18 @@ public class HighlightUtil { @Nullable public static HighlightInfo checkSingleImportClassConflict(PsiImportStatement statement, - Map> singleImportedClasses) { + Map> singleImportedClasses) { if (statement.isOnDemand()) return null; PsiElement element = statement.resolve(); if (element instanceof PsiClass) { String name = ((PsiClass)element).getName(); - Pair imported = singleImportedClasses.get(name); + Pair imported = singleImportedClasses.get(name); PsiClass importedClass = imported == null ? null : imported.getSecond(); if (importedClass != null && !element.getManager().areElementsEquivalent(importedClass, element)) { String description = JavaErrorMessages.message("single.import.class.conflict", formatClass(importedClass)); return HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, statement, description); } - singleImportedClasses.put(name, Pair.create(statement, (PsiClass)element)); + singleImportedClasses.put(name, Pair.create((PsiImportStaticReferenceElement)statement.getReference(), (PsiClass)element)); } return null; } diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java index 365c796548f0..f672902708f1 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java @@ -44,7 +44,6 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.xml.XmlAttributeValue; import gnu.trove.THashMap; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import java.util.Collection; @@ -67,7 +66,7 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh private final Map> myFinalVarProblems = new THashMap>(); private final Map myParameterIsReassigned = new THashMap(); - private final Map> mySingleImportedClasses = new THashMap>(); + private final Map> mySingleImportedClasses = new THashMap>(); private final Map> mySingleImportedFields = new THashMap>(); private PsiFile myFile; private final PsiElementVisitor REGISTER_REFERENCES_VISITOR = new PsiRecursiveElementWalkingVisitor() { @@ -445,50 +444,52 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh } } - @Override public void visitImportStatement(PsiImportStatement statement) { + @Override + public void visitImportStatement(final PsiImportStatement statement) { if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkSingleImportClassConflict(statement, mySingleImportedClasses)); } - @Override public void visitImportStaticReferenceElement(PsiImportStaticReferenceElement ref) { - String refName = ref.getReferenceName(); - JavaResolveResult[] results = ref.multiResolve(false); + @Override + public void visitImportStaticReferenceElement(final PsiImportStaticReferenceElement ref) { + final String refName = ref.getReferenceName(); + final JavaResolveResult[] results = ref.multiResolve(false); if (results.length == 0) { - String description = JavaErrorMessages.message("cannot.resolve.symbol", refName); - HighlightInfo info = HighlightInfo.createHighlightInfo(HighlightInfoType.WRONG_REF, ref.getReferenceNameElement(), description); - myHolder.add(info); + final String description = JavaErrorMessages.message("cannot.resolve.symbol", refName); + final PsiElement nameElement = ref.getReferenceNameElement(); + assert nameElement != null : ref; + final HighlightInfo info = HighlightInfo.createHighlightInfo(HighlightInfoType.WRONG_REF, nameElement, description); QuickFixAction.registerQuickFixAction(info, SetupJDKFix.getInstnace()); + myHolder.add(info); } else { - PsiManager manager = ref.getManager(); + final PsiManager manager = ref.getManager(); for (JavaResolveResult result : results) { - PsiElement element = result.getElement(); - if (!(element instanceof PsiModifierListOwner) || !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { - continue; - } - @NonNls String messageKey = null; - if (element instanceof PsiClass) { - Pair imported = mySingleImportedClasses.get(refName); - PsiClass aClass = imported == null ? null : imported.getSecond(); - PsiImportStaticStatement statement = (PsiImportStaticStatement)ref.getParent(); + final PsiElement element = result.getElement(); - if (aClass != null && !manager.areElementsEquivalent(aClass, element) && !imported.getFirst().equals(statement)) { - messageKey = "class.is.already.defined.in.single.type.import"; + String description = null; + if (element instanceof PsiClass) { + final Pair imported = mySingleImportedClasses.get(refName); + final PsiClass aClass = imported == null ? null : imported.getSecond(); + if (aClass != null && !manager.areElementsEquivalent(aClass, element)) { + description = imported.getFirst().equals(ref) + ? JavaErrorMessages.message("class.is.ambiguous.in.single.static.import", refName) + : JavaErrorMessages.message("class.is.already.defined.in.single.static.import", refName); } - mySingleImportedClasses.put(refName, Pair.create(statement, (PsiClass)element)); + mySingleImportedClasses.put(refName, Pair.create(ref, (PsiClass)element)); } else if (element instanceof PsiField) { - Pair imported = mySingleImportedFields.get(refName); - PsiField field = imported == null ? null : imported.getSecond(); - - if (field != null && !manager.areElementsEquivalent(field, element) && !imported.getFirst().equals(ref.getParent())) { - messageKey = "field.is.already.defined.in.single.type.import"; + final Pair imported = mySingleImportedFields.get(refName); + final PsiField field = imported == null ? null : imported.getSecond(); + if (field != null && !manager.areElementsEquivalent(field, element)) { + description = imported.getFirst().equals(ref) + ? JavaErrorMessages.message("field.is.ambiguous.in.single.static.import", refName) + : JavaErrorMessages.message("field.is.already.defined.in.single.static.import", refName); } mySingleImportedFields.put(refName, Pair.create(ref, (PsiField)element)); } - if (messageKey != null) { - String description = JavaErrorMessages.message(messageKey, refName); + if (description != null) { myHolder.add(HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, ref, description)); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/PsiImportStaticReferenceElementImpl.java b/java/java-impl/src/com/intellij/psi/impl/source/PsiImportStaticReferenceElementImpl.java index 91b3a4a33e48..fbfbbb3bc222 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/PsiImportStaticReferenceElementImpl.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/PsiImportStaticReferenceElementImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2011 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,14 +18,12 @@ package com.intellij.psi.impl.source; import com.intellij.codeInsight.daemon.JavaErrorMessages; import com.intellij.lang.ASTNode; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.openapi.util.Key; import com.intellij.openapi.util.TextRange; import com.intellij.psi.*; import com.intellij.psi.filters.ClassFilter; import com.intellij.psi.impl.source.resolve.ResolveCache; +import com.intellij.psi.impl.source.resolve.StaticImportResolveProcessor; import com.intellij.psi.impl.source.tree.*; -import com.intellij.psi.scope.BaseScopeProcessor; -import com.intellij.psi.scope.NameHint; import com.intellij.psi.scope.PsiScopeProcessor; import com.intellij.psi.scope.processor.FilterScopeProcessor; import com.intellij.psi.scope.util.PsiScopesUtil; @@ -36,9 +34,6 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; -import java.util.ArrayList; -import java.util.List; - /** * @author dsl */ @@ -217,98 +212,17 @@ public class PsiImportStaticReferenceElementImpl extends CompositePsiElement imp return (JavaResolveResult[])resolveCache.resolveWithCaching(this, OurGenericsResolver.INSTANCE, true, incompleteCode); } - private class OurResolveResult implements JavaResolveResult { - final PsiMember myTarget; - Boolean myAccessible = null; - - - public OurResolveResult(PsiMember target) { - myTarget = target; - } - - public PsiMember getElement() { - return myTarget; - } - - public PsiSubstitutor getSubstitutor() { - return PsiSubstitutor.EMPTY; - } - - public boolean isValidResult() { - return isAccessible(); - } - - public boolean isAccessible() { - if (myAccessible == null) { - myAccessible = JavaPsiFacade.getInstance(getProject()).getResolveHelper().isAccessible(myTarget, PsiImportStaticReferenceElementImpl.this, null); - } - return myAccessible.booleanValue(); - } - - public boolean isStaticsScopeCorrect() { - return true; - } - - public PsiElement getCurrentFileResolveScope() { - return null; - } - - public boolean isPackagePrefixPackageReference() { - return false; - } - - } - private static final class OurGenericsResolver implements ResolveCache.PolyVariantResolver { private static final OurGenericsResolver INSTANCE = new OurGenericsResolver(); - public JavaResolveResult[] resolve(PsiImportStaticReferenceElementImpl referenceElement, boolean incompleteCode) { + + public JavaResolveResult[] resolve(final PsiImportStaticReferenceElementImpl referenceElement, final boolean incompleteCode) { final PsiElement qualifier = referenceElement.getQualifier(); if (!(qualifier instanceof PsiJavaCodeReferenceElement)) return JavaResolveResult.EMPTY_ARRAY; final PsiElement target = ((PsiJavaCodeReferenceElement)qualifier).resolve(); if (!(target instanceof PsiClass)) return JavaResolveResult.EMPTY_ARRAY; - final ArrayList results = new ArrayList(); - target - .processDeclarations(referenceElement.new MyScopeProcessor(results), ResolveState.initial(), referenceElement, referenceElement); - if (results.size() <= 1) { - return results.toArray(new JavaResolveResult[results.size()]); - } - for(int i = results.size() - 1; i >= 0; i--) { - final JavaResolveResult resolveResult = results.get(i); - if (!resolveResult.isValidResult()) { - results.remove(i); - } - } - return results.toArray(new JavaResolveResult[results.size()]); - } - - } - - private class MyScopeProcessor extends BaseScopeProcessor implements NameHint { - private final List myResults; - - public MyScopeProcessor(List results) { - myResults = results; - } - - public boolean execute(PsiElement element, ResolveState state) { - if (element instanceof PsiMember - && ((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) { - myResults.add(new OurResolveResult((PsiMember)element)); - } - return true; - } - - public String getName(ResolveState state) { - return getReferenceName(); - } - - @Override - public T getHint(Key hintKey) { - if (hintKey == NameHint.KEY) { - return (T)this; - } - - return super.getHint(hintKey); + final StaticImportResolveProcessor processor = new StaticImportResolveProcessor(referenceElement); + target.processDeclarations(processor, ResolveState.initial(), referenceElement, referenceElement); + return processor.getResults(); } } @@ -329,7 +243,7 @@ public class PsiImportStaticReferenceElementImpl extends CompositePsiElement imp public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException { PsiElement oldIdentifier = findChildByRoleAsPsiElement(ChildRole.REFERENCE_NAME); - if (oldIdentifier == null){ + if (oldIdentifier == null) { throw new IncorrectOperationException(); } PsiIdentifier identifier = JavaPsiFacade.getInstance(getProject()).getElementFactory().createIdentifier(newElementName); diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java index 4ae2285edc66..1d741a13066c 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2011 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. @@ -111,10 +111,6 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi return file instanceof PsiJavaFile && ((PsiJavaFile)file).getPackageName().equals(packageName); } - private static enum Domination { - DOMINATES, DOMINATED_BY, EQUAL - } - private Domination dominates(PsiClass aClass, boolean accessible, String fqName, ClassCandidateInfo info) { final PsiClass otherClass = info.getElement(); assert otherClass != null; @@ -195,8 +191,7 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi } private boolean checkAccessibility(final PsiClass aClass) { - //We don't care about accessibility in javadocs - + //We don't care about accessibility in javadoc if (JavaResolveUtil.isInJavaDoc(myPlace)) { return true; } @@ -233,17 +228,17 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); if (aClass.hasModifierProperty(PsiModifier.PROTECTED)) { accessible = false; - if (facade.arePackagesTheSame(aClass, myPlace)) { + if (myPlace != null && facade.arePackagesTheSame(aClass, myPlace)) { accessible = true; } else { if (aClass.getContainingClass() != null) { - accessible = myAccessClass == null || facade.getResolveHelper().isAccessible(aClass, myPlace, myAccessClass); + accessible = myAccessClass == null || myPlace != null && facade.getResolveHelper().isAccessible(aClass, myPlace, myAccessClass); } } } if (aClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { - if (!facade.arePackagesTheSame(aClass, myPlace)) { + if (myPlace == null || !facade.arePackagesTheSame(aClass, myPlace)) { accessible = false; } } @@ -253,9 +248,9 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi @Override public T getHint(Key hintKey) { if (hintKey == ElementClassHint.KEY || hintKey == NameHint.KEY) { + //noinspection unchecked return (T)this; } - return super.getHint(hintKey); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/Domination.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/Domination.java new file mode 100644 index 000000000000..a967384b2c0d --- /dev/null +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/Domination.java @@ -0,0 +1,20 @@ +/* + * Copyright 2000-2011 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. + */ +package com.intellij.psi.impl.source.resolve; + +public enum Domination { + DOMINATES, DOMINATED_BY, EQUAL +} diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/StaticImportResolveProcessor.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/StaticImportResolveProcessor.java new file mode 100644 index 000000000000..ce3364b63d5b --- /dev/null +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/StaticImportResolveProcessor.java @@ -0,0 +1,141 @@ +/* + * Copyright 2000-2011 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. + */ +package com.intellij.psi.impl.source.resolve; + +import com.intellij.openapi.util.Key; +import com.intellij.psi.*; +import com.intellij.psi.infos.CandidateInfo; +import com.intellij.psi.scope.BaseScopeProcessor; +import com.intellij.psi.scope.NameHint; +import com.intellij.util.SmartList; + +import java.util.List; +import java.util.ListIterator; + +public class StaticImportResolveProcessor extends BaseScopeProcessor implements NameHint { + private final PsiImportStaticReferenceElement myReference; + private final String myName; + private final List myFieldResults = new SmartList(); + private final List myClassResult = new SmartList(); + private final List myResults = new SmartList(); + + public StaticImportResolveProcessor(final PsiImportStaticReferenceElement reference) { + myReference = reference; + myName = myReference.getReferenceName(); + } + + public boolean execute(final PsiElement candidate, final ResolveState state) { + if (candidate instanceof PsiMember && ((PsiModifierListOwner)candidate).hasModifierProperty(PsiModifier.STATIC)) { + if (candidate instanceof PsiField) { + if (checkDomination((PsiMember)candidate, myFieldResults)) return true; + myFieldResults.add(new OurResolveResult(candidate, myReference)); + } + else if (candidate instanceof PsiClass) { + if (checkDomination((PsiMember)candidate, myClassResult)) return true; + myClassResult.add(new OurResolveResult(candidate, myReference)); + } + else { + myResults.add(new OurResolveResult(candidate, myReference)); + } + } + return true; + } + + private static boolean checkDomination(final PsiMember candidate, final List results) { + if (results.size() > 0) { + for (ListIterator i = results.listIterator(results.size()); i.hasPrevious();) { + final Domination domination = dominates(candidate, (PsiMember)i.previous().getElement()); + if (domination == Domination.DOMINATED_BY) { + return true; + } + else if (domination == Domination.DOMINATES) { + i.remove(); + } + } + } + return false; + } + + private static Domination dominates(final PsiMember member1, final PsiMember member2) { + final PsiClass class1 = member1.getContainingClass(); + final PsiClass class2 = member2.getContainingClass(); + if (class1 != null && class2 != null) { + if (class1.isInheritor(class2, true)) { + return Domination.DOMINATES; + } + else if (class2.isInheritor(class1, true)) { + return Domination.DOMINATED_BY; + } + } + return Domination.EQUAL; + } + + public String getName(final ResolveState state) { + return myName; + } + + @Override + public T getHint(final Key hintKey) { + if (hintKey == NameHint.KEY) { + //noinspection unchecked + return (T)this; + } + return super.getHint(hintKey); + } + + public JavaResolveResult[] getResults() { + if (myResults.size() + myFieldResults.size() + myClassResult.size() > 1) { + filterInvalid(myResults); + filterInvalid(myFieldResults); + filterInvalid(myClassResult); + } + if (!myFieldResults.isEmpty()) { + myResults.addAll(myFieldResults); + } + if (!myClassResult.isEmpty()) { + myResults.addAll(myClassResult); + } + return myResults.toArray(new JavaResolveResult[myResults.size()]); + } + + private static void filterInvalid(final List resultList) { + if (resultList.isEmpty()) return; + for (ListIterator i = resultList.listIterator(resultList.size()); i.hasPrevious();) { + if (!i.previous().isValidResult()) i.remove(); + } + } + + private static class OurResolveResult extends CandidateInfo { + private final PsiImportStaticReferenceElement myReference; + + public OurResolveResult(final PsiElement candidate, final PsiImportStaticReferenceElement reference) { + super(candidate, PsiSubstitutor.EMPTY); + myReference = reference; + } + + @Override + public boolean isAccessible() { + final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(myReference.getProject()).getResolveHelper(); + final PsiElement element = getElement(); + return element instanceof PsiMember && resolveHelper.isAccessible((PsiMember)element, myReference, null); + } + + @Override + public boolean isStaticsScopeCorrect() { + return true; + } + } +} diff --git a/java/java-impl/src/com/intellij/psi/scope/NameHint.java b/java/java-impl/src/com/intellij/psi/scope/NameHint.java index 558b30f92c01..be526419b8f4 100644 --- a/java/java-impl/src/com/intellij/psi/scope/NameHint.java +++ b/java/java-impl/src/com/intellij/psi/scope/NameHint.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2011 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. @@ -17,9 +17,11 @@ package com.intellij.psi.scope; import com.intellij.openapi.util.Key; import com.intellij.psi.ResolveState; +import org.jetbrains.annotations.Nullable; public interface NameHint { Key KEY = Key.create("NameHint"); + @Nullable String getName(ResolveState state); } diff --git a/java/java-impl/src/com/intellij/psi/scope/processor/ConflictFilterProcessor.java b/java/java-impl/src/com/intellij/psi/scope/processor/ConflictFilterProcessor.java index e6ff85329f71..6f587da170e0 100644 --- a/java/java-impl/src/com/intellij/psi/scope/processor/ConflictFilterProcessor.java +++ b/java/java-impl/src/com/intellij/psi/scope/processor/ConflictFilterProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2011 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. @@ -27,21 +27,17 @@ import com.intellij.psi.util.PsiUtil; import java.util.List; /** - * Created by IntelliJ IDEA. - * User: ik + * @author ik * Date: 31.03.2003 - * Time: 14:46:31 - * To change this template use Options | File Templates. */ -public class ConflictFilterProcessor extends FilterScopeProcessor implements NameHint{ +public class ConflictFilterProcessor extends FilterScopeProcessor implements NameHint { private final PsiConflictResolver[] myResolvers; private JavaResolveResult[] myCachedResult = null; protected String myName; protected final PsiElement myPlace; protected final PsiFile myPlaceFile; - public ConflictFilterProcessor(String name, ElementFilter filter, PsiConflictResolver[] resolvers, List container, - final PsiElement place){ + public ConflictFilterProcessor(String name, ElementFilter filter, PsiConflictResolver[] resolvers, List container, PsiElement place) { super(filter, container); myResolvers = resolvers; myName = name; @@ -49,34 +45,33 @@ public class ConflictFilterProcessor extends FilterScopeProcessor myPlaceFile = place.getContainingFile(); } - public boolean execute(PsiElement element, ResolveState state){ - if(myCachedResult != null && myCachedResult.length == 1 && myCachedResult[0].isAccessible()) { + public boolean execute(PsiElement element, ResolveState state) { + if (myCachedResult != null && myCachedResult.length == 1 && myCachedResult[0].isAccessible()) { return false; } - - if(myName == null || PsiUtil.checkName(element, myName, myPlace)){ + if (myName == null || PsiUtil.checkName(element, myName, myPlace)) { return super.execute(element, state); } return true; } - protected void add(PsiElement element, PsiSubstitutor substitutor){ + protected void add(PsiElement element, PsiSubstitutor substitutor) { add(new CandidateInfo(element, substitutor)); } - protected void add(CandidateInfo info){ + protected void add(CandidateInfo info) { myCachedResult = null; myResults.add(info); } - public void handleEvent(Event event, Object associated){ - if(event == JavaScopeProcessorEvent.CHANGE_LEVEL && myName != null){ + public void handleEvent(Event event, Object associated) { + if (event == JavaScopeProcessorEvent.CHANGE_LEVEL && myName != null) { getResult(); } } - public JavaResolveResult[] getResult(){ - if(myCachedResult == null){ + public JavaResolveResult[] getResult() { + if (myCachedResult == null) { final List conflicts = getResults(); for (PsiConflictResolver resolver : myResolvers) { CandidateInfo candidate = resolver.resolveConflict(conflicts); @@ -92,16 +87,17 @@ public class ConflictFilterProcessor extends FilterScopeProcessor return myCachedResult; } - public String getName(ResolveState state){ + public String getName(ResolveState state) { return myName; } - public void setName(String name){ + public void setName(String name) { myName = name; } public T getHint(Key hintKey) { - if (hintKey == NameHint.KEY){ + if (hintKey == NameHint.KEY) { + //noinspection unchecked return myName != null ? (T)this : null; } return super.getHint(hintKey); diff --git a/java/java-impl/src/com/intellij/psi/scope/processor/FilterScopeProcessor.java b/java/java-impl/src/com/intellij/psi/scope/processor/FilterScopeProcessor.java index ff6aedebdb47..466bc063fbd4 100644 --- a/java/java-impl/src/com/intellij/psi/scope/processor/FilterScopeProcessor.java +++ b/java/java-impl/src/com/intellij/psi/scope/processor/FilterScopeProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2011 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. @@ -23,52 +23,50 @@ import com.intellij.psi.filters.ElementFilter; import com.intellij.psi.scope.BaseScopeProcessor; import com.intellij.psi.scope.PsiScopeProcessor; import com.intellij.util.SmartList; +import org.jetbrains.annotations.Nullable; import java.util.List; /** - * Created by IntelliJ IDEA. - * User: ik + * @author ik * Date: 13.02.2003 - * Time: 15:21:27 - * To change this template use Options | File Templates. */ -public class FilterScopeProcessor extends BaseScopeProcessor{ +public class FilterScopeProcessor extends BaseScopeProcessor { protected final List myResults; private PsiElement myCurrentDeclarationHolder; private final ElementFilter myFilter; private final PsiScopeProcessor myProcessor; - public FilterScopeProcessor(ElementFilter filter, PsiScopeProcessor processor, List container){ + public FilterScopeProcessor(ElementFilter filter, List container) { + this(filter, null, container); + } + + public FilterScopeProcessor(ElementFilter filter, PsiScopeProcessor processor) { + this(filter, processor, new SmartList()); + } + + public FilterScopeProcessor(ElementFilter filter) { + this(filter, null, new SmartList()); + } + + public FilterScopeProcessor(ElementFilter filter, @Nullable PsiScopeProcessor processor, List container) { myFilter = filter; myProcessor = processor; myResults = container; } - public FilterScopeProcessor(ElementFilter filter, List container){ - this(filter, null, container); - } - - public FilterScopeProcessor(ElementFilter filter, PsiScopeProcessor proc){ - this(filter, proc, new SmartList()); - } - - public FilterScopeProcessor(ElementFilter filter){ - this(filter, null, new SmartList()); - } - - public void handleEvent(Event event, Object associated){ - if(myProcessor != null){ + public void handleEvent(Event event, Object associated) { + if (myProcessor != null) { myProcessor.handleEvent(event, associated); } - if(event == Event.SET_DECLARATION_HOLDER && associated instanceof PsiElement){ + if (event == Event.SET_DECLARATION_HOLDER && associated instanceof PsiElement) { myCurrentDeclarationHolder = (PsiElement)associated; } } - public boolean execute(PsiElement element, ResolveState state){ - if (myFilter.isAcceptable(element, myCurrentDeclarationHolder)){ - if(myProcessor != null){ + public boolean execute(PsiElement element, ResolveState state) { + if (myFilter.isAcceptable(element, myCurrentDeclarationHolder)) { + if (myProcessor != null) { return myProcessor.execute(element, state); } add(element, state.get(PsiSubstitutor.KEY)); @@ -76,7 +74,8 @@ public class FilterScopeProcessor extends BaseScopeProcessor{ return true; } - protected void add(PsiElement element, PsiSubstitutor substitutor){ + protected void add(PsiElement element, PsiSubstitutor substitutor) { + //noinspection unchecked myResults.add((T)element); } @@ -88,7 +87,7 @@ public class FilterScopeProcessor extends BaseScopeProcessor{ return null; } - public List getResults(){ + public List getResults() { return myResults; } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/Usage.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/Usage.java index 2fc102ab046e..58d350cfe02e 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/Usage.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/Usage.java @@ -1,3 +1,28 @@ -import static x.Base2.f; +/* + * Copyright 2000-2011 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. + */ +import x.Base1; +import static x.Base2.F; +import static x.Base2.m; +import static x.Base2.II.IF; + class Usage { + void use() { + m(Base1.F); //Base1.m(int) + m(F); //Base2.m(float) + F.class.getName(); // Base2.F + m(IF); + } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base1.java index 806e7245b587..197ec8d762fc 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base1.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base1.java @@ -1,5 +1,28 @@ +/* + * Copyright 2000-2011 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. + */ package x; public class Base1 { - public static void f() {} -} + public static final int F = 1; + public static void m(int i) { } + public static class F { } + public interface I1 { + int IF = 1; + } + public interface I2 { + float IF = 2.0f; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base2.java index 3cc84ff93016..faa9512d6328 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base2.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/staticImportConflict/x/Base2.java @@ -1,5 +1,23 @@ +/* + * Copyright 2000-2011 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. + */ package x; public class Base2 extends Base1 { - public static void f() {} -} + public static final float F = 2.0f; + public static void m(float f) { } + public static class F { } + public interface II extends I1, I2 { } +} \ No newline at end of file diff --git a/resources-en/src/messages/JavaErrorMessages.properties b/resources-en/src/messages/JavaErrorMessages.properties index 465e1e1b75e1..93a57976ab2e 100644 --- a/resources-en/src/messages/JavaErrorMessages.properties +++ b/resources-en/src/messages/JavaErrorMessages.properties @@ -240,8 +240,10 @@ static.imports.prior.15=Static imports are not supported at this language level varargs.prior.15=Variable arity methods are not supported at this language level foreach.prior.15=Foreach loops are not supported at this language level annotations.prior.15=Annotations are not supported at this language level -class.is.already.defined.in.single.type.import=class ''{0}'' is already defined in a single-type import -field.is.already.defined.in.single.type.import=field ''{0}'' is already defined in a single-type import +class.is.already.defined.in.single.static.import=Class ''{0}'' is already defined in a single static import +class.is.ambiguous.in.single.static.import=Class ''{0}'' is ambiguous in a single static import +field.is.already.defined.in.single.static.import=Field ''{0}'' is already defined in a single static import +field.is.ambiguous.in.single.static.import=Field ''{0}'' is ambiguous in a single static import annotation.interface.members.may.not.have.parameters=@interface members may not have parameters local.variable.is.never.used=Variable ''{0}'' is never used