Java PsiClassReferenceType类代码示例

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public Stream<LookupElementBuilder> resolveCompletions(String propertyName, PsiType psiType) {
    PsiType[] parameters = ((PsiClassReferenceType) psiType).getParameters();
    Stream<PsiClass> psiClassStream = null;
    if (parameters.length == 1 && parameters[0] instanceof PsiWildcardType) {
        PsiWildcardType psiWildcardType = ((PsiWildcardType) parameters[0]);
        if (psiWildcardType.isBounded()) {
            if (psiWildcardType.isExtends()) {
                psiClassStream = subClasses((PsiClassType) psiWildcardType.getExtendsBound()).stream();
            } else if (psiWildcardType.isSuper()) {
                psiClassStream = superClasses((PsiClassType) psiWildcardType.getSuperBound()).stream();
            }
        }
    }
    if (psiClassStream != null) {
        return psiClassStream.map(this::buildClassLookup).filter(Optional::isPresent).map(Optional::get);
    } else {
        return Stream.empty();
    }
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
private boolean isPsiMethodCamelLanguage(PsiMethod method) {
    PsiType type = method.getReturnType();
    if (type != null && type instanceof PsiClassReferenceType) {
        PsiClassReferenceType clazz = (PsiClassReferenceType) type;
        PsiClass resolved = clazz.resolve();
        if (resolved != null) {
            boolean language = getCamelIdeaUtils().isCamelExpressionOrLanguage(resolved);
            // try parent using some weird/nasty stub stuff which is how complex IDEA AST
            // is when its parsing the Camel route builder
            if (!language) {
                PsiElement elem = resolved.getParent();
                if (elem instanceof PsiTypeParameterList) {
                    elem = elem.getParent();
                }
                if (elem instanceof PsiClass) {
                    language = getCamelIdeaUtils().isCamelExpressionOrLanguage((PsiClass) elem);
                }
            }
            return language;
        }
    }

    return false;
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public SmartTypePointer visitClassType(PsiClassType classType) {
  final PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics();
  final PsiClass aClass = resolveResult.getElement();
  if (aClass == null) {
    return createClassReferenceTypePointer(classType);
  }
  if (classType instanceof PsiClassReferenceType) {
    classType = ((PsiClassReferenceType)classType).createImmediateCopy();
  }
  final PsiSubstitutor substitutor = resolveResult.getSubstitutor();
  final HashMap<SmartPsiElementPointer, SmartTypePointer> map = new HashMap<SmartPsiElementPointer, SmartTypePointer>();
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(aClass)) {
    final PsiType substitutionResult = substitutor.substitute(typeParameter);
    if (substitutionResult != null) {
      final SmartPsiElementPointer pointer = myPsiPointerManager.createSmartPsiElementPointer(typeParameter);
      map.put(pointer, substitutionResult.accept(this));
    }
  }
  return new ClassTypePointer(classType, myPsiPointerManager.createSmartPsiElementPointer(aClass), map);
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public PsiType getType() {
  PsiJavaCodeReferenceElement qualifier = getQualifier();
  if (qualifier != null){
    PsiElement qualifierResolve = qualifier.resolve();
    if (qualifierResolve instanceof PsiClass) return new PsiImmediateClassType((PsiClass)qualifierResolve, PsiSubstitutor.EMPTY);
    return new PsiClassReferenceType(qualifier, null);
  }
  for(PsiElement scope = getContext(); scope != null; scope = scope.getContext()){
    if (scope instanceof PsiClass){
      PsiClass aClass = (PsiClass)scope;
      return new PsiImmediateClassType(aClass, PsiSubstitutor.EMPTY);
    }
    else if (scope instanceof PsiExpressionList && scope.getParent() instanceof PsiAnonymousClass){
      scope = scope.getParent();
    }
    else if (scope instanceof JavaCodeFragment){
      PsiType fragmentThisType = ((JavaCodeFragment)scope).getThisType();
      if (fragmentThisType != null) return fragmentThisType;
    }
  }
  return null;
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
public void testParameterListInExtends() throws Exception {
  final PsiManager manager = PsiManager.getInstance(myProject);
  final PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
  final PsiClass classFromText = factory.createClassFromText("class X extends Y<Z, W> {}", null);
  final PsiClass classX = classFromText.getInnerClasses()[0];
  final PsiJavaCodeReferenceElement[] extendsOfX = classX.getExtendsList().getReferenceElements();
  assertEquals(1, extendsOfX.length);
  final PsiJavaCodeReferenceElement ref = extendsOfX[0];
  assertEquals("Y<Z,W>", ref.getCanonicalText());
  assertEquals("Y", ref.getReferenceName());
  final PsiTypeElement[] refParams = ref.getParameterList().getTypeParameterElements();
  assertEquals(2, refParams.length);
  assertEquals("Z", refParams[0].getType().getCanonicalText());
  assertEquals("W", refParams[1].getType().getCanonicalText());
  final PsiType refType = factory.createType(ref);
  assertEquals("Y<Z,W>", refType.getCanonicalText());
  final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) refType).getReference();
  assertEquals("Y<Z,W>", reference.getCanonicalText());
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
    public void readMethod(PsiCodeBlock methodBody, PsiElementFactory factory, PsiField field) {
        if (null == methodBody) {
            return;
        }

        String fieldName = field.getName();
        String parameterType = ((PsiClassReferenceType) field.getType()).getParameters()[0].getPresentableText();

//        // phones = new ArrayList<>();
//        // in.readTypedList(phones, Phone.CREATOR);
//        methodBody.add(factory.createStatementFromText(fieldName + " = new ArrayList<" + parameterType + ">();", null));
//        methodBody.add(factory.createStatementFromText("in.readTypedList(" + fieldName + ", " + parameterType + ".CREATOR);", null));

        // phones = in.createTypedArrayList(Phone.CREATOR);
        methodBody.add(factory.createStatementFromText(fieldName + " = in.createTypedArrayList(" + parameterType + ".CREATOR);", null));


    }
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
UnresolvedClassItem(@NotNull final Converter env, @NotNull final PsiClassReferenceType cls, @Nullable final Parent parent) {
  this.env = env;
  this.cls = cls;
  PsiPackage pkg = Place.getElementPackage(cls.getReference(), env.project);
  _parent = parent == null ? pkg == null ? LocalPkg$.MODULE$ : (Package)env.addContainer(pkg) : parent;

  if (cls instanceof PsiModifierListOwner) {
    _isFinal = ((PsiModifierListOwner)cls).hasModifierProperty(PsiModifier.FINAL);
    _isAbstract = ((PsiModifierListOwner)cls).hasModifierProperty(PsiModifier.ABSTRACT);
    _isStatic = Place.isStatic((PsiModifierListOwner) cls);
  }

  List<TypeArg> jargs = new SmartList<TypeArg>();
  for (PsiType arg : cls.getParameters())
    jargs.add(env.convertTypeArg(arg,parent));
  _targs = scala.collection.JavaConversions.asScalaBuffer(jargs).toList();
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Nullable
@Override
public TypeBuilder visitClassType(PsiClassType classType) {
    String name = (classType instanceof PsiClassReferenceType) ?
            ((PsiClassReferenceType) classType).getReference().getQualifiedName() :
            classType.getClassName();

    String mappedName = typeParameterMap.containsKey(name) ? typeParameterMap.get(name) : name;

    typeBuilder.withName(mappedName);

    for (PsiType param : classType.getParameters()) {
        PsiTypeParameterConverter converter = new PsiTypeParameterConverter(typeParameterMap);
        param.accept(converter);
        typeBuilder.withTypeBinding(converter.getTypeParameterBuilder());
    }

    return super.visitClassType(classType);
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Nullable
public static InflateContainer matchInflate(PsiLocalVariable psiLocalVariable) {
    PsiType psiType = psiLocalVariable.getType();
    if(psiType instanceof PsiClassReferenceType) {
        PsiMethodCallExpression psiMethodCallExpression = PsiTreeUtil.findChildOfType(psiLocalVariable, PsiMethodCallExpression.class);
        if(psiMethodCallExpression != null) {
            PsiMethod psiMethod = psiMethodCallExpression.resolveMethod();

            // @TODO: replace "inflate"; resolve method and check nethod calls
            if(psiMethod != null && psiMethod.getName().equals("inflate")) {
                PsiExpression[] expressions = psiMethodCallExpression.getArgumentList().getExpressions();
                if(expressions.length > 0 && expressions[0] instanceof PsiReferenceExpression) {
                    PsiFile xmlFile = AndroidUtils.findXmlResource((PsiReferenceExpression) expressions[0]);
                    if(xmlFile != null) {
                        return new InflateContainer(xmlFile, ((PsiLocalVariable) psiLocalVariable));
                    }
                }
            }
        }
    }

    return null;
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public SmartTypePointer visitClassType(PsiClassType classType) {
  final PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics();
  final PsiClass aClass = resolveResult.getElement();
  if (aClass == null) {
    if (classType instanceof PsiClassReferenceType) {
      return new ClassReferenceTypePointer((PsiClassReferenceType)classType);
    }
    return new SimpleTypePointer(classType);
  }
  if (classType instanceof PsiClassReferenceType) {
    classType = ((PsiClassReferenceType)classType).createImmediateCopy();
  }
  final PsiSubstitutor substitutor = resolveResult.getSubstitutor();
  final HashMap<SmartPsiElementPointer, SmartTypePointer> map = new HashMap<SmartPsiElementPointer, SmartTypePointer>();
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(aClass)) {
    final PsiType substitutionResult = substitutor.substitute(typeParameter);
    if (substitutionResult != null) {
      final SmartPsiElementPointer pointer = myPsiPointerManager.createSmartPsiElementPointer(typeParameter);
      map.put(pointer, substitutionResult.accept(this));
    }
  }
  return new ClassTypePointer(classType, myPsiPointerManager.createSmartPsiElementPointer(aClass), map);
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public PsiType getType() {
  PsiJavaCodeReferenceElement qualifier = getQualifier();
  if (qualifier != null){
    PsiClass qualifierResolve = (PsiClass)qualifier.resolve();
    if (qualifierResolve != null) return new PsiImmediateClassType(qualifierResolve, PsiSubstitutor.EMPTY);

    return new PsiClassReferenceType(qualifier, null);
  }
  for(PsiElement scope = getContext(); scope != null; scope = scope.getContext()){
    if (scope instanceof PsiClass){
      PsiClass aClass = (PsiClass)scope;
      return new PsiImmediateClassType(aClass, PsiSubstitutor.EMPTY);
    }
    else if (scope instanceof PsiExpressionList && scope.getParent() instanceof PsiAnonymousClass){
      scope = scope.getParent();
    }
    else if (scope instanceof JavaCodeFragment){
      PsiType fragmentThisType = ((JavaCodeFragment)scope).getThisType();
      if (fragmentThisType != null) return fragmentThisType;
    }
  }
  return null;
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@NotNull
private static String getTypeText(@Nullable PsiType type, boolean isDumb)
{
	// todo PsiTypeVisitor ?
	String result;
	if(type == null)
	{
		result = "";
	}
	else if(!isDumb || type instanceof PsiPrimitiveType)
	{
		result = type.getCanonicalText(false);
	}
	else if(type instanceof PsiClassReferenceType)
	{
		result = ((PsiClassReferenceType) type).getReference().getReferenceName();
	}
	else
	{
		result = "";
	}
	return getShortClassName(notNullize(result));
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public boolean canHandle(PsiType psiType) {
    if (psiType instanceof PsiClassReferenceType) {
        PsiClass resolved = ((PsiClassReferenceType) psiType).resolve();
        return resolved != null && resolved.isEnum();
    }
    return false;
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public Stream<LookupElementBuilder> resolveCompletions(String propertyName, PsiType psiType) {
    PsiClass resolved = ((PsiClassReferenceType) psiType).resolve();
    if (resolved != null) {
        return Arrays.stream(resolved.getChildren())
                .filter(child -> child instanceof PsiEnumConstant)
                .map(child -> buildEnumLookup((PsiEnumConstant) child))
                .filter(Optional::isPresent)
                .map(Optional::get);
    }
    return Stream.empty();
}
 

import com.intellij.psi.impl.source.PsiClassReferenceType; //导入依赖的package包/类
@Override
public boolean canHandle(PsiType psiType) {
    if (psiType instanceof PsiClassReferenceType) {
        PsiClass resolved = ((PsiClassReferenceType) psiType).resolve();
        if (resolved != null && JAVA_LANG_CLASS.equals(resolved.getQualifiedName())) {
            return true;
        }
    }
    return false;
}