java/java-impl/src/com/intellij/psi/impl/source/PsiClassReferenceType.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.psi.impl.source;
  17
  18 import com.intellij.openapi.util.Comparing;
  19 import com.intellij.pom.java.LanguageLevel;
  20 import com.intellij.psi.*;
  21 import com.intellij.psi.impl.light.LightClassReference;
  22 import com.intellij.psi.search.GlobalSearchScope;
  23 import com.intellij.psi.util.PsiTreeUtil;
  24 import com.intellij.psi.util.PsiUtil;
  25 import org.jetbrains.annotations.NotNull;
  26
  27 /**
  28  * @author max
  29  */
  30 public class PsiClassReferenceType extends PsiClassType {
  31   private final PsiJavaCodeReferenceElement myReference;
  32
  33   public PsiClassReferenceType(@NotNull PsiJavaCodeReferenceElement reference, LanguageLevel languageLevel) {
  34     super(languageLevel, extractAnnosFromReference(reference));
  35     myReference = reference;
  36   }
  37
  38   private static PsiAnnotation[] extractAnnosFromReference(PsiJavaCodeReferenceElement reference) {
  39     PsiAnnotation[] annotations = PsiTreeUtil.getChildrenOfType(reference, PsiAnnotation.class);
  40     return annotations == null ? PsiAnnotation.EMPTY_ARRAY : annotations;
  41   }
  42
  43   public PsiClassReferenceType(@NotNull PsiJavaCodeReferenceElement reference, LanguageLevel languageLevel, PsiAnnotation[] annotations) {
  44     super(languageLevel,annotations);
  45     myReference = reference;
  46   }
  47
  48   public boolean isValid() {
  49     return myReference.isValid();
  50   }
  51
  52   public boolean equalsToText(String text) {
  53     return Comparing.equal(text, getCanonicalText());
  54   }
  55
  56   @NotNull
  57   public GlobalSearchScope getResolveScope() {
  58     return myReference.getResolveScope();
  59   }
  60
  61   @NotNull
  62   public LanguageLevel getLanguageLevel() {
  63     if (myLanguageLevel != null) return myLanguageLevel;
  64     return PsiUtil.getLanguageLevel(myReference);
  65   }
  66
  67   public PsiClassType setLanguageLevel(final LanguageLevel languageLevel) {
  68     if (languageLevel.equals(myLanguageLevel)) return this;
  69     return new PsiClassReferenceType(myReference,languageLevel,getAnnotations());
  70   }
  71
  72   public PsiClass resolve() {
  73     return resolveGenerics().getElement();
  74   }
  75
  76   private static class DelegatingClassResolveResult implements ClassResolveResult {
  77     private final JavaResolveResult myDelegate;
  78
  79     private DelegatingClassResolveResult(JavaResolveResult delegate) {
  80       myDelegate = delegate;
  81     }
  82
  83     public PsiSubstitutor getSubstitutor() {
  84       return myDelegate.getSubstitutor();
  85     }
  86
  87     public boolean isValidResult() {
  88       return myDelegate.isValidResult();
  89     }
  90
  91     public boolean isAccessible() {
  92       return myDelegate.isAccessible();
  93     }
  94
  95     public boolean isStaticsScopeCorrect() {
  96       return myDelegate.isStaticsScopeCorrect();
  97     }
  98
  99     public PsiElement getCurrentFileResolveScope() {
 100       return myDelegate.getCurrentFileResolveScope();
 101     }
 102
 103     public boolean isPackagePrefixPackageReference() {
 104       return myDelegate.isPackagePrefixPackageReference();
 105     }
 106
 107     public PsiClass getElement() {
 108       final PsiElement element = myDelegate.getElement();
 109       return element instanceof PsiClass ? (PsiClass)element : null;
 110     }
 111   }
 112
 113   @NotNull
 114   public ClassResolveResult resolveGenerics() {
 115     final JavaResolveResult result = myReference.advancedResolve(false);
 116     return new DelegatingClassResolveResult(result);
 117   }
 118
 119   @NotNull
 120   public PsiClassType rawType() {
 121     PsiElement resolved = myReference.resolve();
 122     if (resolved instanceof PsiClass) {
 123       PsiClass aClass = (PsiClass)resolved;
 124       if (!PsiUtil.typeParametersIterable(aClass).iterator().hasNext()) return this;
 125       PsiManager manager = myReference.getManager();
 126       final PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
 127       final PsiSubstitutor rawSubstitutor = factory.createRawSubstitutor(aClass);
 128       return factory.createType(aClass, rawSubstitutor, getLanguageLevel(), getAnnotations());
 129     }
 130     String qualifiedName = myReference.getQualifiedName();
 131     LightClassReference reference = new LightClassReference(myReference.getManager(), myReference.getReferenceName(), qualifiedName, myReference.getResolveScope());
 132     return new PsiClassReferenceType(reference, null,getAnnotations());
 133   }
 134
 135   public String getClassName() {
 136     return myReference.getReferenceName();
 137   }
 138
 139   @NotNull
 140   public PsiType[] getParameters() {
 141     return myReference.getTypeParameters();
 142   }
 143
 144   public PsiClassType createImmediateCopy() {
 145     final ClassResolveResult resolveResult = resolveGenerics();
 146     if (resolveResult.getElement() == null) return this;
 147     return new PsiImmediateClassType(resolveResult.getElement(), resolveResult.getSubstitutor());
 148   }
 149
 150   public String getPresentableText() {
 151     return getAnnotationsTextPrefix() + PsiNameHelper.getPresentableText(myReference);
 152   }
 153
 154   public String getCanonicalText() {
 155     return myReference.getCanonicalText();
 156   }
 157
 158   public String getInternalCanonicalText() {
 159     return getAnnotationsTextPrefix() + getCanonicalText();
 160   }
 161
 162   public PsiJavaCodeReferenceElement getReference() {
 163     return myReference;
 164   }
 165 }