diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFactoryImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFactoryImpl.java index 2226bdfacb83..25eeac26ab20 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFactoryImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFactoryImpl.java @@ -183,11 +183,7 @@ public class PsiElementFactoryImpl extends PsiJavaParserFacadeImpl implements Ps if (type instanceof PsiClassReferenceType) { return ((PsiClassReferenceType)type).getReference(); } - - final PsiClassType.ClassResolveResult resolveResult = type.resolveGenerics(); - final PsiClass refClass = resolveResult.getElement(); - assert refClass != null : type; - return new LightClassReference(myManager, type.getCanonicalText(true), refClass, resolveResult.getSubstitutor()); + return new LightClassTypeReference(myManager, type); } @NotNull diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReference.java b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReference.java index 1455314f6249..a6be6bd58930 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReference.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReference.java @@ -15,27 +15,21 @@ */ package com.intellij.psi.impl.light; -import com.intellij.lang.java.JavaLanguage; -import com.intellij.openapi.util.TextRange; import com.intellij.psi.*; import com.intellij.psi.infos.CandidateInfo; -import com.intellij.psi.scope.PsiScopeProcessor; import com.intellij.psi.search.GlobalSearchScope; -import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public class LightClassReference extends LightElement implements PsiJavaCodeReferenceElement { - private final String myText; +public class LightClassReference extends LightClassReferenceBase implements PsiJavaCodeReferenceElement { + private final String myClassName; private final PsiElement myContext; @NotNull private final GlobalSearchScope myResolveScope; private final PsiClass myRefClass; private final PsiSubstitutor mySubstitutor; - private LightReferenceParameterList myParameterList; - private LightClassReference(@NotNull PsiManager manager, @NotNull @NonNls String text, @Nullable @NonNls String className, @@ -43,8 +37,7 @@ public class LightClassReference extends LightElement implements PsiJavaCodeRefe @NotNull GlobalSearchScope resolveScope, @Nullable PsiElement context, @Nullable PsiClass refClass) { - super(manager, JavaLanguage.INSTANCE); - myText = text; + super(manager, text); myClassName = className; myResolveScope = resolveScope; @@ -107,32 +100,6 @@ public class LightClassReference extends LightElement implements PsiJavaCodeRefe return new CandidateInfo(resolved, substitutor); } - @Override - @NotNull - public JavaResolveResult[] multiResolve(boolean incompleteCode){ - final JavaResolveResult result = advancedResolve(incompleteCode); - if(result != JavaResolveResult.EMPTY) return new JavaResolveResult[]{result}; - return JavaResolveResult.EMPTY_ARRAY; - } - - @Override - public void processVariants(@NotNull PsiScopeProcessor processor){ - throw new RuntimeException("Variants are not available for light references"); - } - - @Override - public PsiElement getReferenceNameElement() { - return null; - } - - @Override - public PsiReferenceParameterList getParameterList() { - if (myParameterList == null) { - myParameterList = new LightReferenceParameterList(myManager, PsiTypeElement.EMPTY_ARRAY); - } - return myParameterList; - } - @Override public String getQualifiedName() { if (myClassName != null) { @@ -162,36 +129,6 @@ public class LightClassReference extends LightElement implements PsiJavaCodeRefe } } - @Override - public String getText() { - return myText; - } - - @Override - public PsiReference getReference() { - return this; - } - - @Override - @NotNull - public String getCanonicalText() { - String name = getQualifiedName(); - if (name == null) return ""; - PsiType[] types = getTypeParameters(); - if (types.length == 0) return name; - - StringBuilder buf = new StringBuilder(); - buf.append(name); - buf.append('<'); - for (int i = 0; i < types.length; i++) { - if (i > 0) buf.append(','); - buf.append(types[i].getCanonicalText()); - } - buf.append('>'); - - return buf.toString(); - } - @Override public PsiElement copy() { if (myClassName != null) { @@ -207,79 +144,11 @@ public class LightClassReference extends LightElement implements PsiJavaCodeRefe } } - @Override - public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException { - //TODO? - throw new UnsupportedOperationException(); - } - - @Override - public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException { - //TODO? - throw new UnsupportedOperationException(); - } - - @Override - public void accept(@NotNull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitReferenceElement(this); - } - else { - visitor.visitElement(this); - } - } - - public String toString() { - return "LightClassReference:" + myText; - } - - @Override - public boolean isReferenceTo(PsiElement element) { - return element instanceof PsiClass && getManager().areElementsEquivalent(resolve(), element); - } - - @Override - @NotNull - public Object[] getVariants() { - throw new RuntimeException("Variants are not available for light references"); - } - - @Override - public boolean isSoft(){ - return false; - } - - @Override - public TextRange getRangeInElement() { - return new TextRange(0, getTextLength()); - } - - @Override - public PsiElement getElement() { - return this; - } - @Override public boolean isValid() { return myRefClass == null || myRefClass.isValid(); } - @Override - @NotNull - public PsiType[] getTypeParameters() { - return PsiType.EMPTY_ARRAY; - } - - @Override - public PsiElement getQualifier() { - return null; - } - - @Override - public boolean isQualified() { - return false; - } - @NotNull @Override public GlobalSearchScope getResolveScope() { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReferenceBase.java b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReferenceBase.java new file mode 100644 index 000000000000..ad1026018a55 --- /dev/null +++ b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassReferenceBase.java @@ -0,0 +1,168 @@ +/* + * Copyright 2000-2016 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.light; + +import com.intellij.lang.java.JavaLanguage; +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.*; +import com.intellij.psi.scope.PsiScopeProcessor; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; + +abstract class LightClassReferenceBase extends LightElement implements PsiJavaCodeReferenceElement { + + protected final String myText; + + private LightReferenceParameterList myParameterList; + + protected LightClassReferenceBase(@NotNull PsiManager manager, @NotNull String text) { + super(manager, JavaLanguage.INSTANCE); + myText = text; + } + + @Override + @NotNull + public JavaResolveResult[] multiResolve(boolean incompleteCode) { + final JavaResolveResult result = advancedResolve(incompleteCode); + if (result != JavaResolveResult.EMPTY) return new JavaResolveResult[]{result}; + return JavaResolveResult.EMPTY_ARRAY; + } + + @Override + public void processVariants(@NotNull PsiScopeProcessor processor) { + throw new RuntimeException("Variants are not available for light references"); + } + + @Override + public PsiElement getReferenceNameElement() { + return null; + } + + @Override + public PsiReferenceParameterList getParameterList() { + if (myParameterList == null) { + myParameterList = new LightReferenceParameterList(myManager, PsiTypeElement.EMPTY_ARRAY); + } + return myParameterList; + } + + @Override + public String getQualifiedName() { + PsiClass psiClass = (PsiClass)resolve(); + if (psiClass != null) { + return psiClass.getQualifiedName(); + } + return null; + } + + @Override + public String getText() { + return myText; + } + + @Override + public PsiReference getReference() { + return this; + } + + @Override + @NotNull + public String getCanonicalText() { + String name = getQualifiedName(); + if (name == null) return ""; + PsiType[] types = getTypeParameters(); + if (types.length == 0) return name; + + StringBuilder buf = new StringBuilder(); + buf.append(name); + buf.append('<'); + for (int i = 0; i < types.length; i++) { + if (i > 0) buf.append(','); + buf.append(types[i].getCanonicalText()); + } + buf.append('>'); + + return buf.toString(); + } + + @Override + public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException { + //TODO? + throw new UnsupportedOperationException(); + } + + @Override + public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException { + //TODO? + throw new UnsupportedOperationException(); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitReferenceElement(this); + } + else { + visitor.visitElement(this); + } + } + + public String toString() { + return getClass().getSimpleName() + getText(); + } + + @Override + public boolean isReferenceTo(PsiElement element) { + return element instanceof PsiClass && getManager().areElementsEquivalent(resolve(), element); + } + + @Override + @NotNull + public Object[] getVariants() { + throw new RuntimeException("Variants are not available for light references"); + } + + @Override + public boolean isSoft() { + return false; + } + + @Override + public TextRange getRangeInElement() { + return new TextRange(0, getTextLength()); + } + + @Override + public PsiElement getElement() { + return this; + } + + @Override + @NotNull + public PsiType[] getTypeParameters() { + return PsiType.EMPTY_ARRAY; + } + + @Override + public PsiElement getQualifier() { + return null; + } + + @Override + public boolean isQualified() { + return false; + } +} diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassTypeReference.java b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassTypeReference.java new file mode 100644 index 000000000000..940f0e4b248c --- /dev/null +++ b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightClassTypeReference.java @@ -0,0 +1,69 @@ +/* + * Copyright 2000-2016 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.light; + +import com.intellij.psi.*; +import com.intellij.psi.search.GlobalSearchScope; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +public class LightClassTypeReference extends LightClassReferenceBase implements PsiJavaCodeReferenceElement { + + private final @NotNull PsiClassType myType; + + private LightClassTypeReference(@NotNull PsiManager manager, @NotNull String text, @NotNull PsiClassType type) { + super(manager, text); + myType = type; + } + + public LightClassTypeReference(@NotNull PsiManager manager, @NotNull PsiClassType type) { + this(manager, type.getCanonicalText(true), type); + } + + @Nullable + @Override + public PsiElement resolve() { + return myType.resolve(); + } + + @NotNull + @Override + public JavaResolveResult advancedResolve(boolean incompleteCode) { + return myType.resolveGenerics(); + } + + @Nullable + @Override + public String getReferenceName() { + return myType.getClassName(); + } + + @Override + public PsiElement copy() { + return new LightClassTypeReference(myManager, myText, myType); + } + + @Override + public boolean isValid() { + return myType.isValid(); + } + + @NotNull + @Override + public GlobalSearchScope getResolveScope() { + return myType.getResolveScope(); + } +}