diff options
Diffstat (limited to 'java/java-psi-impl/src/com/intellij/psi')
19 files changed, 186 insertions, 161 deletions
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsJavaCodeReferenceElementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsJavaCodeReferenceElementImpl.java index 7b44a496416c..a4fc56e0cf89 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsJavaCodeReferenceElementImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsJavaCodeReferenceElementImpl.java @@ -15,18 +15,21 @@ */ package com.intellij.psi.impl.compiled; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.TextRange; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; import com.intellij.psi.impl.PsiSubstitutorImpl; +import com.intellij.psi.impl.ResolveScopeManager; import com.intellij.psi.impl.cache.TypeInfo; import com.intellij.psi.impl.source.resolve.ResolveCache; import com.intellij.psi.impl.source.tree.JavaElementType; import com.intellij.psi.impl.source.tree.TreeElement; import com.intellij.psi.infos.CandidateInfo; import com.intellij.psi.scope.PsiScopeProcessor; +import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.TypeConversionUtil; @@ -44,7 +47,7 @@ public class ClsJavaCodeReferenceElementImpl extends ClsElementImpl implements P private final String myQualifiedName; private final PsiReferenceParameterList myRefParameterList; - public ClsJavaCodeReferenceElementImpl(PsiElement parent, String canonicalText) { + public ClsJavaCodeReferenceElementImpl(PsiElement parent, @NotNull String canonicalText) { myParent = parent; String canonical = TypeInfo.internFrequentType(canonicalText); @@ -88,20 +91,20 @@ public class ClsJavaCodeReferenceElementImpl extends ClsElementImpl implements P return myCanonicalText; } - private static class Resolver implements ResolveCache.PolyVariantResolver<ClsJavaCodeReferenceElementImpl> { + private static class Resolver implements ResolveCache.PolyVariantContextResolver<ClsJavaCodeReferenceElementImpl> { public static final Resolver INSTANCE = new Resolver(); @NotNull @Override - public JavaResolveResult[] resolve(@NotNull ClsJavaCodeReferenceElementImpl ref, boolean incompleteCode) { - final JavaResolveResult resolveResult = ref.advancedResolveImpl(); + public JavaResolveResult[] resolve(@NotNull ClsJavaCodeReferenceElementImpl ref, @NotNull PsiFile containingFile, boolean incompleteCode) { + final JavaResolveResult resolveResult = ref.advancedResolveImpl(containingFile); return resolveResult == null ? JavaResolveResult.EMPTY_ARRAY : new JavaResolveResult[] {resolveResult}; } } - private JavaResolveResult advancedResolveImpl() { + private JavaResolveResult advancedResolveImpl(@NotNull PsiFile containingFile) { PsiTypeElement[] typeElements = myRefParameterList == null ? PsiTypeElement.EMPTY_ARRAY : myRefParameterList.getTypeParameterElements(); - PsiElement resolve = resolveElement(); + PsiElement resolve = resolveElement(containingFile); if (resolve == null) return null; if (resolve instanceof PsiClass) { Map<PsiTypeParameter, PsiType> substitutionMap = new HashMap<PsiTypeParameter, PsiType>(); @@ -137,7 +140,7 @@ public class ClsJavaCodeReferenceElementImpl extends ClsElementImpl implements P } } - private void collectOuterClassTypeArgs(final PsiClass psiClass, + private void collectOuterClassTypeArgs(@NotNull PsiClass psiClass, final String canonicalText, final Map<PsiTypeParameter, PsiType> substitutionMap) { final PsiClass containingClass = psiClass.getContainingClass(); @@ -179,7 +182,7 @@ public class ClsJavaCodeReferenceElementImpl extends ClsElementImpl implements P } @Nullable - private PsiElement resolveElement() { + private PsiElement resolveElement(@NotNull PsiFile containingFile) { PsiElement element = getParent(); while(element != null && (!(element instanceof PsiClass) || element instanceof PsiTypeParameter)) { if(element instanceof PsiMethod){ @@ -199,16 +202,18 @@ public class ClsJavaCodeReferenceElementImpl extends ClsElementImpl implements P for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable((PsiTypeParameterListOwner)element)) { if (myQualifiedName.equals(parameter.getName())) return parameter; } - return resolveClassPreferringMyJar(); + return resolveClassPreferringMyJar(containingFile); } @Nullable - private PsiClass resolveClassPreferringMyJar() { - PsiClass[] classes = JavaPsiFacade.getInstance(getProject()).findClasses(myQualifiedName, getResolveScope()); + private PsiClass resolveClassPreferringMyJar(@NotNull PsiFile containingFile) { + Project project = containingFile.getProject(); + GlobalSearchScope scope = ResolveScopeManager.getInstance(project).getResolveScope(this); + PsiClass[] classes = JavaPsiFacade.getInstance(project).findClasses(myQualifiedName, scope); if (classes.length == 0) return null; if (classes.length > 1) { - VirtualFile jarFile = PsiUtil.getJarFile(this); + VirtualFile jarFile = PsiUtil.getJarFile(containingFile); if (jarFile != null) { for (PsiClass aClass : classes) { if (Comparing.equal(PsiUtil.getJarFile(aClass), jarFile)) return aClass; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java index 361f2374b904..3508873df641 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java @@ -208,11 +208,10 @@ public class PsiClassReferenceType extends PsiClassType.Stub { if (myReference instanceof PsiJavaCodeReferenceElementImpl) { PsiAnnotation[] annotations = getAnnotations(); if (!annotated || annotations.length == 0) annotations = null; - return ((PsiJavaCodeReferenceElementImpl)myReference).getCanonicalText(annotated, annotations); - } - else { - return myReference.getCanonicalText(); + PsiJavaCodeReferenceElementImpl impl = (PsiJavaCodeReferenceElementImpl)myReference; + return impl.getCanonicalText(annotated, annotations, impl.getContainingFile()); } + return myReference.getCanonicalText(); } @NotNull diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java index 5ee1243b09ce..1b60c157e248 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java @@ -57,7 +57,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme private volatile String myCachedQName = null; private volatile String myCachedNormalizedText; - private int myKindWhenDummy = CLASS_NAME_KIND; + private volatile int myKindWhenDummy = CLASS_NAME_KIND; public static final int CLASS_NAME_KIND = 1; public static final int PACKAGE_NAME_KIND = 2; @@ -92,8 +92,8 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme return type == TokenType.DUMMY_HOLDER || type == JavaElementType.DUMMY_ELEMENT; } - public int getKind() { - PsiUtilCore.ensureValid(this); + public int getKind(@NotNull PsiFile containingFile) { + PsiUtilCore.ensureValid(containingFile); CompositeElement treeParent = getTreeParent(); IElementType i = treeParent.getElementType(); if (isDummy(i)) { @@ -142,7 +142,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme return CLASS_FQ_OR_PACKAGE_NAME_KIND; } if (i == JavaElementType.JAVA_CODE_REFERENCE) { - int parentKind = ((PsiJavaCodeReferenceElementImpl)treeParent).getKind(); + int parentKind = ((PsiJavaCodeReferenceElementImpl)treeParent).getKind(containingFile); if (parentKind == CLASS_NAME_KIND) { return CLASS_OR_PACKAGE_NAME_KIND; } @@ -256,16 +256,17 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme @Override @NotNull public String getCanonicalText() { - return getCanonicalText(false, null); + return getCanonicalText(false, null, getContainingFile()); } @NotNull - public String getCanonicalText(boolean annotated, @Nullable PsiAnnotation[] annotations) { - switch (getKind()) { + public String getCanonicalText(boolean annotated, @Nullable PsiAnnotation[] annotations, @NotNull PsiFile containingFile) { + switch (getKind(containingFile)) { case CLASS_NAME_KIND: case CLASS_OR_PACKAGE_NAME_KIND: case CLASS_IN_QUALIFIED_NEW_KIND: - final PsiElement target = resolve(); + JavaResolveResult[] results = multiResolve(false, containingFile, containingFile.getProject()); + final PsiElement target = results.length == 1 ? results[0].getElement() : null; if (target instanceof PsiClass) { PsiClass aClass = (PsiClass)target; StringBuilder buffer = new StringBuilder(); @@ -273,7 +274,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme PsiElement qualifier = getQualifier(); String prefix = null; if (qualifier instanceof PsiJavaCodeReferenceElementImpl) { - prefix = ((PsiJavaCodeReferenceElementImpl)qualifier).getCanonicalText(annotated, null); + prefix = ((PsiJavaCodeReferenceElementImpl)qualifier).getCanonicalText(annotated, null, containingFile); } else { String fqn = aClass.getQualifiedName(); @@ -327,15 +328,14 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme return advancedResolve(false).getElement(); } - private static final class OurGenericsResolver implements ResolveCache.PolyVariantResolver<PsiJavaReference> { + private static final class OurGenericsResolver implements ResolveCache.PolyVariantContextResolver<PsiJavaReference> { private static final OurGenericsResolver INSTANCE = new OurGenericsResolver(); @NotNull @Override - public JavaResolveResult[] resolve(@NotNull PsiJavaReference ref, boolean incompleteCode) { + public ResolveResult[] resolve(@NotNull PsiJavaReference ref, @NotNull PsiFile containingFile, boolean incompleteCode) { PsiJavaCodeReferenceElementImpl referenceElement = (PsiJavaCodeReferenceElementImpl)ref; - int kind = referenceElement.getKind(); - PsiFile containingFile = referenceElement.getContainingFile(); + int kind = referenceElement.getKind(containingFile); JavaResolveResult[] result = referenceElement.resolve(kind, containingFile); if (incompleteCode && result.length == 0 && kind != CLASS_FQ_NAME_KIND && kind != CLASS_FQ_OR_PACKAGE_NAME_KIND) { @@ -347,7 +347,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme } } - JavaResolveUtil.substituteResults((PsiJavaCodeReferenceElement)ref, result); + JavaResolveUtil.substituteResults(referenceElement, result); return result; } @@ -373,16 +373,21 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme LOG.error("getManager() == null!"); return JavaResolveResult.EMPTY_ARRAY; } - PsiFile file = SharedImplUtil.getContainingFile(fileElement); - boolean valid = file != null && file.isValid(); + PsiFile containingFile = SharedImplUtil.getContainingFile(fileElement); + boolean valid = containingFile != null && containingFile.isValid(); if (!valid) { LOG.error("invalid!"); return JavaResolveResult.EMPTY_ARRAY; } Project project = manager.getProject(); + return multiResolve(incompleteCode, containingFile, project); + } + + @NotNull + private JavaResolveResult[] multiResolve(boolean incompleteCode, @NotNull PsiFile containingFile, @NotNull Project project) { final ResolveCache resolveCache = ResolveCache.getInstance(project); - final ResolveResult[] results = resolveCache.resolveWithCaching(this, OurGenericsResolver.INSTANCE, true, incompleteCode, file); + final ResolveResult[] results = resolveCache.resolveWithCaching(this, OurGenericsResolver.INSTANCE, true, incompleteCode, containingFile); return results.length == 0 ? JavaResolveResult.EMPTY_ARRAY : (JavaResolveResult[])results; } @@ -394,14 +399,15 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme return subst; } - private JavaResolveResult[] resolve(final int kind, PsiFile containingFile) { + @NotNull + private JavaResolveResult[] resolve(final int kind, @NotNull PsiFile containingFile) { switch (kind) { case CLASS_FQ_NAME_KIND: { // TODO: support type parameters in FQ names String text = getNormalizedText(); if (StringUtil.isEmptyOrSpaces(text)) return JavaResolveResult.EMPTY_ARRAY; - PsiClass aClass = JavaPsiFacade.getInstance(getProject()).findClass(text, getResolveScope()); + PsiClass aClass = JavaPsiFacade.getInstance(containingFile.getProject()).findClass(text, getResolveScope()); if (aClass == null) return JavaResolveResult.EMPTY_ARRAY; if (!isQualified() && text.equals(aClass.getQualifiedName())) { @@ -503,16 +509,17 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme @Override public PsiElement bindToElement(@NotNull final PsiElement element) throws IncorrectOperationException { - CheckUtil.checkWritable(this); + PsiFile containingFile = getContainingFile(); + CheckUtil.checkWritable(containingFile); if (isReferenceTo(element)) return this; - switch (getKind()) { + switch (getKind(containingFile)) { case CLASS_NAME_KIND: case CLASS_FQ_NAME_KIND: if (!(element instanceof PsiClass)) { throw cannotBindError(element); } - return bindToClass((PsiClass)element); + return bindToClass((PsiClass)element, containingFile); case PACKAGE_NAME_KIND: if (!(element instanceof PsiPackage)) { @@ -523,7 +530,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme case CLASS_OR_PACKAGE_NAME_KIND: case CLASS_FQ_OR_PACKAGE_NAME_KIND: if (element instanceof PsiClass) { - return bindToClass((PsiClass)element); + return bindToClass((PsiClass)element, containingFile); } else if (element instanceof PsiPackage) { return bindToPackage((PsiPackage)element); @@ -538,7 +545,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme if (name == null) { throw new IncorrectOperationException(aClass.toString()); } - final PsiJavaParserFacade parserFacade = JavaPsiFacade.getInstance(getProject()).getParserFacade(); + final PsiJavaParserFacade parserFacade = JavaPsiFacade.getInstance(containingFile.getProject()).getParserFacade(); final PsiJavaCodeReferenceElement ref = parserFacade.createReferenceFromText(name, getParent()); getTreeParent().replaceChildInternal(this, (TreeElement)ref.getNode()); return ref; @@ -557,10 +564,11 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme return new IncorrectOperationException("Cannot bind to " + element); } - private PsiElement bindToClass(PsiClass aClass) throws IncorrectOperationException { + private PsiElement bindToClass(@NotNull PsiClass aClass, @NotNull PsiFile containingFile) throws IncorrectOperationException { String qName = aClass.getQualifiedName(); - boolean preserveQualification = JavaCodeStyleSettingsFacade.getInstance(getProject()).useFQClassNames() && isFullyQualified(); - JavaPsiFacade facade = JavaPsiFacade.getInstance(getProject()); + Project project = containingFile.getProject(); + boolean preserveQualification = JavaCodeStyleSettingsFacade.getInstance(project).useFQClassNames() && isFullyQualified(containingFile); + JavaPsiFacade facade = JavaPsiFacade.getInstance(project); if (qName == null) { qName = aClass.getName(); PsiClass psiClass = facade.getResolveHelper().resolveReferencedClass(qName, this); @@ -583,7 +591,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme ((PsiJavaCodeReferenceElementImpl)ref).setAnnotations(annotations); if (!preserveQualification) { - JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(aClass.getProject()); + JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project); ref = (PsiJavaCodeReferenceElement)codeStyleManager.shortenClassReferences(ref, JavaCodeStyleManager.UNCOMPLETE_CODE); } @@ -631,8 +639,8 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme } } - private boolean isFullyQualified() { - switch (getKind()) { + private boolean isFullyQualified(@NotNull PsiFile containingFile) { + switch (getKind(containingFile)) { case CLASS_OR_PACKAGE_NAME_KIND: if (resolve() instanceof PsiPackage) return true; //noinspection fallthrough @@ -656,10 +664,10 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme final PsiElement refElement = SourceTreeToPsiMap.<PsiJavaCodeReferenceElement>treeToPsiNotNull(qualifier).resolve(); if (refElement instanceof PsiPackage) return true; - return SourceTreeToPsiMap.<PsiJavaCodeReferenceElementImpl>treeToPsiNotNull(qualifier).isFullyQualified(); + return SourceTreeToPsiMap.<PsiJavaCodeReferenceElementImpl>treeToPsiNotNull(qualifier).isFullyQualified(containingFile); } - private PsiElement bindToPackage(final PsiPackage aPackage) throws IncorrectOperationException { + private PsiElement bindToPackage(@NotNull PsiPackage aPackage) throws IncorrectOperationException { final String qName = aPackage.getQualifiedName(); if (qName.isEmpty()) { throw new IncorrectOperationException("Cannot bind to default package: "+aPackage); @@ -672,7 +680,12 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme @Override public boolean isReferenceTo(final PsiElement element) { - switch (getKind()) { + PsiFile containingFile = getContainingFile(); + return isReferenceTo(element, containingFile); + } + + private boolean isReferenceTo(PsiElement element, @NotNull PsiFile containingFile) { + switch (getKind(containingFile)) { case CLASS_NAME_KIND: case CLASS_IN_QUALIFIED_NEW_KIND: if (!(element instanceof PsiClass)) return false; @@ -681,44 +694,40 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme case CLASS_FQ_NAME_KIND: { if (!(element instanceof PsiClass)) return false; final String qName = ((PsiClass)element).getQualifiedName(); - return qName != null && qName.equals(getCanonicalText()); + return qName != null && qName.equals(getCanonicalText(false, null, containingFile)); } case PACKAGE_NAME_KIND: { if (!(element instanceof PsiPackage)) return false; final String qName = ((PsiPackage)element).getQualifiedName(); - return qName.equals(getCanonicalText()); + return qName.equals(getCanonicalText(false, null, containingFile)); } case CLASS_OR_PACKAGE_NAME_KIND: // if (lastChild.type != IDENTIFIER) return false; if (element instanceof PsiPackage) { final String qName = ((PsiPackage)element).getQualifiedName(); - return qName.equals(getCanonicalText()); + return qName.equals(getCanonicalText(false, null, containingFile)); } - else if (element instanceof PsiClass) { + if (element instanceof PsiClass) { final PsiIdentifier nameIdentifier = ((PsiClass)element).getNameIdentifier(); if (nameIdentifier == null) return false; PsiElement nameElement = getReferenceNameElement(); return nameElement != null && nameElement.textMatches(nameIdentifier) && - element.getManager().areElementsEquivalent(resolve(), element); - } - else { - return false; + containingFile.getManager().areElementsEquivalent(resolve(), element); } + return false; case CLASS_FQ_OR_PACKAGE_NAME_KIND: if (element instanceof PsiClass) { final String qName = ((PsiClass)element).getQualifiedName(); - return qName != null && qName.equals(getCanonicalText()); + return qName != null && qName.equals(getCanonicalText(false, null, containingFile)); } - else if (element instanceof PsiPackage) { + if (element instanceof PsiPackage) { final String qName = ((PsiPackage)element).getQualifiedName(); - return qName.equals(getCanonicalText()); - } - else { - return false; + return qName.equals(getCanonicalText(false, null, containingFile)); } + return false; default: LOG.assertTrue(false); return true; @@ -727,7 +736,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme final ASTNode referenceNameElement = getReferenceNameNode(); if (referenceNameElement == null || referenceNameElement.getElementType() != JavaTokenType.IDENTIFIER) return false; final String name = ((PsiClass)element).getName(); - return name != null && referenceNameElement.getText().equals(name) && element.getManager().areElementsEquivalent(resolve(), element); + return name != null && referenceNameElement.getText().equals(name) && containingFile.getManager().areElementsEquivalent(resolve(), element); } private String getNormalizedText() { @@ -748,8 +757,8 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme } @Override - public void fullyQualify(final PsiClass targetClass) { - final int kind = getKind(); + public void fullyQualify(@NotNull final PsiClass targetClass) { + final int kind = getKind(getContainingFile()); if (kind != CLASS_NAME_KIND && kind != CLASS_OR_PACKAGE_NAME_KIND && kind != CLASS_IN_QUALIFIED_NEW_KIND) { LOG.error("Wrong kind " + kind); return; @@ -778,32 +787,31 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme @NotNull public Object[] getVariants() { final ElementFilter filter; - switch (getKind()) { - - case CLASS_OR_PACKAGE_NAME_KIND: - filter = new OrFilter(); - ((OrFilter)filter).addFilter(ElementClassFilter.CLASS); - ((OrFilter)filter).addFilter(ElementClassFilter.PACKAGE_FILTER); - break; - case CLASS_NAME_KIND: - filter = ElementClassFilter.CLASS; - break; - case PACKAGE_NAME_KIND: - filter = ElementClassFilter.PACKAGE_FILTER; - break; - case CLASS_FQ_NAME_KIND: - case CLASS_FQ_OR_PACKAGE_NAME_KIND: - filter = new OrFilter(); - ((OrFilter)filter).addFilter(ElementClassFilter.PACKAGE_FILTER); - if (isQualified()) { - ((OrFilter)filter).addFilter(ElementClassFilter.CLASS); - } - break; - case CLASS_IN_QUALIFIED_NEW_KIND: - filter = ElementClassFilter.CLASS; - break; - default: - throw new RuntimeException("Unknown reference type"); + switch (getKind(getContainingFile())) { + case CLASS_OR_PACKAGE_NAME_KIND: + filter = new OrFilter(); + ((OrFilter)filter).addFilter(ElementClassFilter.CLASS); + ((OrFilter)filter).addFilter(ElementClassFilter.PACKAGE_FILTER); + break; + case CLASS_NAME_KIND: + filter = ElementClassFilter.CLASS; + break; + case PACKAGE_NAME_KIND: + filter = ElementClassFilter.PACKAGE_FILTER; + break; + case CLASS_FQ_NAME_KIND: + case CLASS_FQ_OR_PACKAGE_NAME_KIND: + filter = new OrFilter(); + ((OrFilter)filter).addFilter(ElementClassFilter.PACKAGE_FILTER); + if (isQualified()) { + ((OrFilter)filter).addFilter(ElementClassFilter.CLASS); + } + break; + case CLASS_IN_QUALIFIED_NEW_KIND: + filter = ElementClassFilter.CLASS; + break; + default: + throw new RuntimeException("Unknown reference type"); } return PsiImplUtil.getReferenceVariantsByFilter(this, filter); @@ -821,7 +829,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme filter.addFilter(new AndFilter(ElementClassFilter.METHOD, new NotFilter(new ConstructorFilter()))); filter.addFilter(ElementClassFilter.VARIABLE); } - switch (getKind()) { + switch (getKind(getContainingFile())) { case CLASS_OR_PACKAGE_NAME_KIND: filter.addFilter(ElementClassFilter.CLASS); filter.addFilter(ElementClassFilter.PACKAGE_FILTER); @@ -899,7 +907,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme @Override public String getQualifiedName() { - switch (getKind()) { + switch (getKind(getContainingFile())) { case CLASS_NAME_KIND: case CLASS_OR_PACKAGE_NAME_KIND: case CLASS_IN_QUALIFIED_NEW_KIND: diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/SourceJavaCodeReference.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/SourceJavaCodeReference.java index cd3d5e4bdf52..9680725c73fd 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/SourceJavaCodeReference.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/SourceJavaCodeReference.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. @@ -17,6 +17,7 @@ package com.intellij.psi.impl.source; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; /** * This interface should be implemented by all PsiJavaCodeReference implementations @@ -35,9 +36,8 @@ public interface SourceJavaCodeReference { * Helper method for ReferenceAdjuster. Tries to qualify this reference as if * it references <code>targetClass</code>. Does not check that it indeed references * targetClass - * @param targetClass */ - void fullyQualify(PsiClass targetClass); + void fullyQualify(@NotNull PsiClass targetClass); boolean isQualified(); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java index b109372cc882..a2e5593478eb 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ClassResolverProcessor.java @@ -35,6 +35,8 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi private static final String[] DEFAULT_PACKAGES = {CommonClassNames.DEFAULT_PACKAGE}; private final String myClassName; + @NotNull + private final PsiFile myContainingFile; private final PsiElement myPlace; private PsiClass myAccessClass = null; private List<ClassCandidateInfo> myCandidates = null; @@ -43,8 +45,9 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi private JavaResolveResult[] myResult = JavaResolveResult.EMPTY_ARRAY; private PsiElement myCurrentFileContext; - public ClassResolverProcessor(String className, @NotNull PsiElement startPlace, PsiFile containingFile) { + public ClassResolverProcessor(@NotNull String className, @NotNull PsiElement startPlace, @NotNull PsiFile containingFile) { myClassName = className; + myContainingFile = containingFile; PsiElement place = containingFile instanceof JavaCodeFragment && ((JavaCodeFragment)containingFile).getVisibilityChecker() != null ? null : startPlace; myPlace = place; if (place instanceof PsiJavaCodeReferenceElement) { @@ -111,7 +114,7 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi String fqn = psiClass.getQualifiedName(); if (fqn == null) return false; - PsiFile file = myPlace == null ? null : FileContextUtil.getContextFile(myPlace); + PsiFile file = myPlace == null ? null : FileContextUtil.getContextFile(myContainingFile); String[] defaultPackages = file instanceof PsiJavaFile ? ((PsiJavaFile)file).getImplicitlyImportedPackages() : DEFAULT_PACKAGES; String packageName = StringUtil.getPackageName(fqn); @@ -123,9 +126,8 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi return file instanceof PsiJavaFile && ((PsiJavaFile)file).getPackageName().equals(packageName); } - private Domination dominates(PsiClass aClass, boolean accessible, String fqName, ClassCandidateInfo info) { + private Domination dominates(@NotNull PsiClass aClass, boolean accessible, @NotNull String fqName, @NotNull ClassCandidateInfo info) { final PsiClass otherClass = info.getElement(); - assert otherClass != null; String otherQName = otherClass.getQualifiedName(); if (fqName.equals(otherQName)) { return Domination.DOMINATED_BY; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/JavaResolveUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/JavaResolveUtil.java index 20db589bef5c..ebeebe24b88d 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/JavaResolveUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/JavaResolveUtil.java @@ -225,7 +225,7 @@ public class JavaResolveUtil { return true; } - public static void substituteResults(final @NotNull PsiJavaCodeReferenceElement ref, @NotNull JavaResolveResult[] result) { + public static void substituteResults(@NotNull final PsiJavaCodeReferenceElement ref, @NotNull JavaResolveResult[] result) { if (result.length > 0 && result[0].getElement() instanceof PsiClass) { for (int i = 0; i < result.length; i++) { final CandidateInfo resolveResult = (CandidateInfo)result[i]; @@ -247,7 +247,7 @@ public class JavaResolveUtil { @NotNull public static <T extends PsiPolyVariantReference> JavaResolveResult[] resolveWithContainingFile(@NotNull T ref, - @NotNull ResolveCache.PolyVariantResolver<T> resolver, + @NotNull ResolveCache.PolyVariantContextResolver<T> resolver, boolean needToPreventRecursion, boolean incompleteCode, @NotNull PsiFile containingFile) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java index 59c8d7f386a1..556bf7152b68 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java @@ -80,8 +80,9 @@ public class PsiResolveHelperImpl implements PsiResolveHelper { final PsiJavaParserFacade parserFacade = JavaPsiFacade.getInstance(myManager.getProject()).getParserFacade(); try { final PsiJavaCodeReferenceElement ref = parserFacade.createReferenceFromText(referenceText, context); - LOG.assertTrue(ref.isValid(), referenceText); - return ResolveClassUtil.resolveClass(ref); + PsiFile containingFile = ref.getContainingFile(); + LOG.assertTrue(containingFile.isValid(), referenceText); + return ResolveClassUtil.resolveClass(ref, containingFile); } catch (IncorrectOperationException e) { return null; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ResolveClassUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ResolveClassUtil.java index 9c3505c160d3..2bedff69ed04 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ResolveClassUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ResolveClassUtil.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. @@ -20,15 +20,16 @@ import com.intellij.psi.*; import com.intellij.psi.impl.source.PsiJavaCodeReferenceElementImpl; import com.intellij.psi.scope.util.PsiScopesUtil; import com.intellij.psi.util.PsiUtil; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; public class ResolveClassUtil { private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.resolve.ResolveClassUtil"); @Nullable - public static PsiClass resolveClass(PsiJavaCodeReferenceElement ref) { + public static PsiClass resolveClass(@NotNull PsiJavaCodeReferenceElement ref, @NotNull PsiFile containingFile) { if (ref instanceof PsiJavaCodeReferenceElementImpl && - ((PsiJavaCodeReferenceElementImpl)ref).getKind() == PsiJavaCodeReferenceElementImpl.CLASS_IN_QUALIFIED_NEW_KIND) { + ((PsiJavaCodeReferenceElementImpl)ref).getKind(containingFile) == PsiJavaCodeReferenceElementImpl.CLASS_IN_QUALIFIED_NEW_KIND) { PsiElement parent = ref.getParent(); if (parent instanceof PsiAnonymousClass){ parent = parent.getParent(); @@ -63,7 +64,7 @@ public class ResolveClassUtil { long time1 = System.currentTimeMillis(); */ - ClassResolverProcessor processor = new ClassResolverProcessor(className, ref, ref.getContainingFile()); + ClassResolverProcessor processor = new ClassResolverProcessor(className, ref, containingFile); PsiScopesUtil.resolveAndWalk(processor, ref, null); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/VariableResolverProcessor.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/VariableResolverProcessor.java index ead814a8ef63..123e750e0a1a 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/VariableResolverProcessor.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/VariableResolverProcessor.java @@ -41,7 +41,7 @@ public class VariableResolverProcessor extends ConflictFilterProcessor implement private final PsiClass myAccessClass; private PsiElement myCurrentFileContext = null; - public VariableResolverProcessor(@NotNull PsiJavaCodeReferenceElement place, PsiFile placeFile) { + public VariableResolverProcessor(@NotNull PsiJavaCodeReferenceElement place, @NotNull PsiFile placeFile) { super(place.getText(), ourFilter, new PsiConflictResolver[]{new JavaVariableConflictResolver()}, new SmartList<CandidateInfo>(), place, placeFile); PsiElement referenceName = place.getReferenceNameElement(); @@ -54,16 +54,20 @@ public class VariableResolverProcessor extends ConflictFilterProcessor implement final JavaResolveResult accessClass = PsiUtil.getAccessObjectClass((PsiExpression)qualifier); final PsiElement element = accessClass.getElement(); if (element instanceof PsiTypeParameter) { - PsiElementFactory factory = JavaPsiFacade.getInstance(element.getProject()).getElementFactory(); + PsiElementFactory factory = JavaPsiFacade.getInstance(placeFile.getProject()).getElementFactory(); final PsiClassType type = factory.createType((PsiTypeParameter)element); final PsiType accessType = accessClass.getSubstitutor().substitute(type); if (accessType instanceof PsiArrayType) { - LanguageLevel languageLevel = PsiUtil.getLanguageLevel(qualifier); + LanguageLevel languageLevel = PsiUtil.getLanguageLevel(placeFile); access = factory.getArrayClass(languageLevel); } - else if (accessType instanceof PsiClassType) access = ((PsiClassType)accessType).resolve(); + else if (accessType instanceof PsiClassType) { + access = ((PsiClassType)accessType).resolve(); + } + } + else if (element instanceof PsiClass) { + access = (PsiClass)element; } - else if (element instanceof PsiClass) access = (PsiClass)element; } myAccessClass = access; } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java index 361462430105..9d9c373159f9 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java @@ -1070,7 +1070,7 @@ public class InferenceSession { session.addConstraint(new StrictSubtypingConstraint(tReturnType, sReturnType)); return true; } else { - return TypeConversionUtil.isAssignable(sReturnType, tReturnType); + return sReturnType != null && tReturnType != null && TypeConversionUtil.isAssignable(tReturnType, sReturnType); } } } @@ -1115,7 +1115,7 @@ public class InferenceSession { session.addConstraint(new StrictSubtypingConstraint(tReturnType, sReturnType)); return true; } else { - return TypeConversionUtil.isAssignable(sReturnType, tReturnType); + return sReturnType != null && tReturnType != null && TypeConversionUtil.isAssignable(tReturnType, sReturnType); } } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/InputOutputConstraintFormula.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/InputOutputConstraintFormula.java index 6ff17092dfd6..67097df574a0 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/InputOutputConstraintFormula.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/InputOutputConstraintFormula.java @@ -65,7 +65,10 @@ public abstract class InputOutputConstraintFormula implements ConstraintFormula } } - collectReturnTypeVariables(session, psiExpression, substitutor.substitute(interfaceMethod.getReturnType()), result); + final PsiType returnType = interfaceMethod.getReturnType(); + if (returnType != null) { + collectReturnTypeVariables(session, psiExpression, substitutor.substitute(returnType), result); + } return result; } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSourceUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSourceUtil.java index f163624c1778..8cf5b5bfbdd2 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSourceUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSourceUtil.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. @@ -19,11 +19,12 @@ import com.intellij.lang.ASTNode; import com.intellij.psi.*; import com.intellij.psi.impl.source.SourceJavaCodeReference; import com.intellij.util.CharTable; +import org.jetbrains.annotations.NotNull; public class JavaSourceUtil { private JavaSourceUtil() { } - public static void fullyQualifyReference(final CompositeElement reference, final PsiClass targetClass) { + public static void fullyQualifyReference(@NotNull CompositeElement reference, @NotNull PsiClass targetClass) { if (((SourceJavaCodeReference)reference).isQualified()) { // qualified reference final PsiClass parentClass = targetClass.getContainingClass(); if (parentClass == null) return; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaTreeGenerator.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaTreeGenerator.java index 918d7fed7237..c310f5effc08 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaTreeGenerator.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaTreeGenerator.java @@ -85,7 +85,7 @@ public class JavaTreeGenerator implements TreeGenerator { boolean isFQ = false; if (original instanceof PsiJavaCodeReferenceElementImpl) { - int kind = ((PsiJavaCodeReferenceElementImpl)original).getKind(); + int kind = ((PsiJavaCodeReferenceElementImpl)original).getKind(original.getContainingFile()); switch (kind) { case PsiJavaCodeReferenceElementImpl.CLASS_OR_PACKAGE_NAME_KIND: case PsiJavaCodeReferenceElementImpl.CLASS_NAME_KIND: diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java index cf25710008bc..503cbf48ddd3 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java @@ -41,14 +41,13 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; -class MethodReferenceResolver implements ResolveCache.PolyVariantResolver<PsiMethodReferenceExpression> { +class MethodReferenceResolver implements ResolveCache.PolyVariantContextResolver<PsiMethodReferenceExpressionImpl> { private static final Logger LOG = Logger.getInstance("#" + MethodReferenceResolver.class.getName()); @NotNull @Override - public ResolveResult[] resolve(@NotNull final PsiMethodReferenceExpression reference, boolean incompleteCode) { - final PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult = PsiMethodReferenceUtil.getQualifierResolveResult( - reference); + public JavaResolveResult[] resolve(@NotNull final PsiMethodReferenceExpressionImpl reference, @NotNull final PsiFile containingFile, boolean incompleteCode) { + final PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult = PsiMethodReferenceUtil.getQualifierResolveResult(reference); final PsiClass containingClass = qualifierResolveResult.getContainingClass(); PsiSubstitutor substitutor = qualifierResolveResult.getSubstitutor(); @@ -87,7 +86,7 @@ class MethodReferenceResolver implements ResolveCache.PolyVariantResolver<PsiMet final PsiConflictResolver conflictResolver = createResolver(reference, qualifierResolveResult, interfaceMethod, signature); final MethodCandidatesProcessor processor = - new MethodCandidatesProcessor(reference, reference.getContainingFile(), new PsiConflictResolver[] {conflictResolver}, new SmartList<CandidateInfo>()) { + new MethodCandidatesProcessor(reference, containingFile, new PsiConflictResolver[] {conflictResolver}, new SmartList<CandidateInfo>()) { @Override protected boolean acceptVarargs() { return true; @@ -156,7 +155,11 @@ class MethodReferenceResolver implements ResolveCache.PolyVariantResolver<PsiMet final PsiSubstitutor receiverSubstitutor = pClass != null ? TypeConversionUtil .getClassSubstitutor(containingClass, pClass, pResult.getSubstitutor()) : null; if (receiverSubstitutor != null) { - if (!method.hasTypeParameters() && signature.getParameterTypes().length == 1) return receiverSubstitutor; + if (!method.hasTypeParameters()) { + if (signature.getParameterTypes().length == 1 || PsiUtil.isRawSubstitutor(containingClass, receiverSubstitutor)) { + return receiverSubstitutor; + } + } psiSubstitutor = receiverSubstitutor; } } @@ -175,7 +178,7 @@ class MethodReferenceResolver implements ResolveCache.PolyVariantResolver<PsiMet return substitutor; } - if (interfaceMethodReturnType != PsiType.VOID) { + if (interfaceMethodReturnType != PsiType.VOID && interfaceMethodReturnType != null) { final PsiType returnType = method.isConstructor() ? composeReturnType(containingClass, substitutor) : method.getReturnType(); if (returnType != null) { session.registerConstraints(returnType, interfaceMethodReturnType); @@ -241,7 +244,7 @@ class MethodReferenceResolver implements ResolveCache.PolyVariantResolver<PsiMet return functionalInterfaceType; } - protected PsiConflictResolver createResolver(PsiMethodReferenceExpression referenceExpression, + protected PsiConflictResolver createResolver(PsiMethodReferenceExpressionImpl referenceExpression, PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult, PsiMethod interfaceMethod, MethodSignature signature) { @@ -257,11 +260,11 @@ class MethodReferenceResolver implements ResolveCache.PolyVariantResolver<PsiMet private static class MethodReferenceConflictResolver extends JavaMethodsConflictResolver { private final MethodSignature mySignature; - private PsiMethodReferenceExpression myReferenceExpression; + private final PsiMethodReferenceExpressionImpl myReferenceExpression; private final PsiMethodReferenceUtil.QualifierResolveResult myQualifierResolveResult; private final boolean myFunctionalMethodVarArgs; - private MethodReferenceConflictResolver(PsiMethodReferenceExpression referenceExpression, + private MethodReferenceConflictResolver(PsiMethodReferenceExpressionImpl referenceExpression, PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult, @Nullable MethodSignature signature, boolean varArgs) { super(referenceExpression, signature != null ? signature.getParameterTypes() : PsiType.EMPTY_ARRAY, PsiUtil.getLanguageLevel(referenceExpression)); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java index 7a82b2437a90..311b161df557 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java @@ -47,6 +47,7 @@ import java.util.Map; public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase implements PsiMethodReferenceExpression { private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiMethodReferenceExpressionImpl"); + private static final MethodReferenceResolver RESOLVER = new MethodReferenceResolver(); public PsiMethodReferenceExpressionImpl() { super(JavaElementType.METHOD_REF_EXPRESSION); @@ -77,7 +78,7 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase final MethodReferenceResolver resolver = new MethodReferenceResolver() { @Override - protected PsiConflictResolver createResolver(PsiMethodReferenceExpression referenceExpression, + protected PsiConflictResolver createResolver(PsiMethodReferenceExpressionImpl referenceExpression, PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult, PsiMethod interfaceMethod, MethodSignature signature) { @@ -90,7 +91,7 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase } }; - final ResolveResult[] result = resolver.resolve(this, false); + final ResolveResult[] result = resolver.resolve(this, getContainingFile(), false); final PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult = PsiMethodReferenceUtil.getQualifierResolveResult(this); final int interfaceArity = interfaceMethod.getParameterList().getParametersCount(); for (ResolveResult resolveResult : result) { @@ -262,12 +263,11 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase LOG.error("invalid!"); return JavaResolveResult.EMPTY_ARRAY; } - final MethodReferenceResolver resolver = new MethodReferenceResolver(); final Map<PsiMethodReferenceExpression, PsiType> map = PsiMethodReferenceUtil.ourRefs.get(); if (map != null && map.containsKey(this)) { - return (JavaResolveResult[])resolver.resolve(this, incompleteCode); + return RESOLVER.resolve(this, file, incompleteCode); } - ResolveResult[] results = ResolveCache.getInstance(getProject()).resolveWithCaching(this, resolver, true, incompleteCode,file); + ResolveResult[] results = ResolveCache.getInstance(getProject()).resolveWithCaching(this, RESOLVER, true, incompleteCode, file); return results.length == 0 ? JavaResolveResult.EMPTY_ARRAY : (JavaResolveResult[])results; } @@ -421,9 +421,7 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase if (interfaceMethod != null) { final PsiType interfaceReturnType = LambdaUtil.getFunctionalInterfaceReturnType(left); - LOG.assertTrue(interfaceReturnType != null); - - if (interfaceReturnType == PsiType.VOID) { + if (interfaceReturnType == PsiType.VOID || interfaceReturnType == null) { return true; } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiNewExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiNewExpressionImpl.java index dc8f0bb75f6e..7862a7381011 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiNewExpressionImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiNewExpressionImpl.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. @@ -136,12 +136,12 @@ public class PsiNewExpressionImpl extends ExpressionPsiElement implements PsiNew return new PsiPolyVariantCachingReference() { @Override @NotNull - public JavaResolveResult[] resolveInner(boolean incompleteCode) { + public JavaResolveResult[] resolveInner(boolean incompleteCode, @NotNull PsiFile containingFile) { ASTNode classRef = findChildByRole(ChildRole.TYPE_REFERENCE); if (classRef != null) { ASTNode argumentList = PsiImplUtil.skipWhitespaceAndComments(classRef.getTreeNext()); if (argumentList != null && argumentList.getElementType() == JavaElementType.EXPRESSION_LIST) { - final JavaPsiFacade facade = JavaPsiFacade.getInstance(getProject()); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(containingFile.getProject()); PsiType aClass = facade.getElementFactory().createType((PsiJavaCodeReferenceElement)SourceTreeToPsiMap.treeElementToPsi(classRef)); return facade.getResolveHelper().multiResolveConstructor((PsiClassType)aClass, (PsiExpressionList)SourceTreeToPsiMap.treeElementToPsi(argumentList), @@ -151,7 +151,7 @@ public class PsiNewExpressionImpl extends ExpressionPsiElement implements PsiNew else{ ASTNode anonymousClassElement = findChildByType(JavaElementType.ANONYMOUS_CLASS); if (anonymousClassElement != null) { - final JavaPsiFacade facade = JavaPsiFacade.getInstance(getProject()); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(containingFile.getProject()); final PsiAnonymousClass anonymousClass = (PsiAnonymousClass)SourceTreeToPsiMap.treeElementToPsi(anonymousClassElement); PsiType aClass = anonymousClass.getBaseClassType(); ASTNode argumentList = anonymousClassElement.findChildByType(JavaElementType.EXPRESSION_LIST); @@ -176,7 +176,7 @@ public class PsiNewExpressionImpl extends ExpressionPsiElement implements PsiNew @Override @NotNull public String getCanonicalText() { - return null; + throw new UnsupportedOperationException(); } @Override diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java index f91f01c3195c..02ffaa6f3c20 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java @@ -181,23 +181,22 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple super.clearCaches(); } - public static final class OurGenericsResolver implements ResolveCache.PolyVariantResolver<PsiJavaReference> { + public static final class OurGenericsResolver implements ResolveCache.PolyVariantContextResolver<PsiJavaReference> { public static final OurGenericsResolver INSTANCE = new OurGenericsResolver(); - @Override @NotNull - public JavaResolveResult[] resolve(@NotNull PsiJavaReference ref, boolean incompleteCode) { + @Override + public ResolveResult[] resolve(@NotNull PsiJavaReference ref, @NotNull PsiFile containingFile, boolean incompleteCode) { PsiReferenceExpressionImpl expression = (PsiReferenceExpressionImpl)ref; CompositeElement treeParent = expression.getTreeParent(); IElementType parentType = treeParent == null ? null : treeParent.getElementType(); - PsiFile file = expression.getContainingFile(); - List<PsiElement> qualifiers = resolveAllQualifiers(expression, file); + List<PsiElement> qualifiers = resolveAllQualifiers(expression, containingFile); try { - JavaResolveResult[] result = expression.resolve(parentType, file); + JavaResolveResult[] result = expression.resolve(parentType, containingFile); if (result.length == 0 && incompleteCode && parentType != JavaElementType.REFERENCE_EXPRESSION) { - result = expression.resolve(JavaElementType.REFERENCE_EXPRESSION, file); + result = expression.resolve(JavaElementType.REFERENCE_EXPRESSION, containingFile); } JavaResolveUtil.substituteResults(expression, result); @@ -213,6 +212,7 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple } } + @NotNull private static List<PsiElement> resolveAllQualifiers(@NotNull PsiReferenceExpressionImpl expression, @NotNull final PsiFile containingFile) { // to avoid SOE, resolve all qualifiers starting from the innermost PsiElement qualifier = expression.getQualifier(); @@ -246,9 +246,9 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple } @NotNull - private JavaResolveResult[] resolve(IElementType parentType, PsiFile containingFile) { + private JavaResolveResult[] resolve(IElementType parentType, @NotNull PsiFile containingFile) { if (parentType == JavaElementType.REFERENCE_EXPRESSION) { - JavaResolveResult[] result = resolveToVariable(); + JavaResolveResult[] result = resolveToVariable(containingFile); if (result.length > 0) { return result; } @@ -280,7 +280,7 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple return resolve(JavaElementType.REFERENCE_EXPRESSION, containingFile); } - return resolveToVariable(); + return resolveToVariable(containingFile); } @NotNull @@ -297,7 +297,7 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple } @NotNull - private JavaResolveResult[] resolveToPackage(PsiFile containingFile) { + private JavaResolveResult[] resolveToPackage(@NotNull PsiFile containingFile) { final String packageName = getCachedNormalizedText(); Project project = containingFile.getProject(); JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); @@ -316,7 +316,7 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple } @NotNull - private JavaResolveResult[] resolveToClass(@NotNull PsiElement classNameElement, PsiFile containingFile) { + private JavaResolveResult[] resolveToClass(@NotNull PsiElement classNameElement, @NotNull PsiFile containingFile) { final String className = classNameElement.getText(); final ClassResolverProcessor processor = new ClassResolverProcessor(className, this, containingFile); @@ -325,8 +325,8 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple } @NotNull - private JavaResolveResult[] resolveToVariable() { - final VariableResolverProcessor processor = new VariableResolverProcessor(this, getContainingFile()); + private JavaResolveResult[] resolveToVariable(@NotNull PsiFile containingFile) { + final VariableResolverProcessor processor = new VariableResolverProcessor(this, containingFile); PsiScopesUtil.resolveAndWalk(processor, this, null); return processor.getResult(); } @@ -730,7 +730,7 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple } @Override - public void fullyQualify(PsiClass targetClass) { + public void fullyQualify(@NotNull PsiClass targetClass) { JavaSourceUtil.fullyQualifyReference(this, targetClass); } diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java index 5f1e2f696961..93a444036bef 100644 --- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java @@ -624,11 +624,11 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{ } if (!applicable12ignoreFunctionalType && applicable21ignoreFunctionalType) { - return specifics == Specifics.SECOND ? Specifics.SECOND : Specifics.NEITHER; + return specifics == Specifics.FIRST ? Specifics.FIRST : Specifics.NEITHER; } if (!applicable21ignoreFunctionalType && applicable12ignoreFunctionalType) { - return specifics == Specifics.FIRST ? Specifics.FIRST : Specifics.NEITHER; + return specifics == Specifics.SECOND ? Specifics.SECOND : Specifics.NEITHER; } return specifics; diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/processor/MethodCandidatesProcessor.java b/java/java-psi-impl/src/com/intellij/psi/scope/processor/MethodCandidatesProcessor.java index 7c83f1065318..7106063217b5 100644 --- a/java/java-psi-impl/src/com/intellij/psi/scope/processor/MethodCandidatesProcessor.java +++ b/java/java-psi-impl/src/com/intellij/psi/scope/processor/MethodCandidatesProcessor.java @@ -94,7 +94,7 @@ public class MethodCandidatesProcessor extends MethodsProcessor{ }; } - protected PsiType[] getExpressionTypes(PsiExpressionList argumentList) { + protected static PsiType[] getExpressionTypes(PsiExpressionList argumentList) { return argumentList != null ? argumentList.getExpressionTypes() : null; } |