do not resolve PsiClassType to create light class reference, wrap PsiClassType instead

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

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() {

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;
+  }
+}

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();
+  }
+}