Java PsiClassType类代码示例

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
@DataProvider
public static Object[][] tooComplexProvider() {
    return testForEach(
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedNameOf(String.class).thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedNameOf(Integer.class).thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedNameOf(List.class).thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedNameOf(Stream.class).thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedNameOf(BufferedReader.class).thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiType.class))
                    .withQualifiedName("some_qualified_name").thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedName(null).thenExpectTheResult().toBeTooGeneric(),
            new TestCase().withTypeMock(mock(PsiClassType.class))
                    .withQualifiedName("myClass").thenExpectTheResult().toBeNotTooGeneric()
    );
}
 

import com.intellij.psi.PsiClassType; //导入依赖的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.PsiClassType; //导入依赖的package包/类
Optional<PsiClass> resolveFieldConfigType(PsiField psiField) {
    PsiType fieldType = psiField.getType();
    if (fieldType instanceof PsiClassType) {
        PsiClassType fieldClassType = ((PsiClassType) fieldType);
        if (collectionType != null && collectionType.isAssignableFrom(fieldType) && fieldClassType.getParameterCount() == 1) {
            return toPsiClass(fieldClassType.getParameters()[0]);
        } else if (mapType != null && mapType.isAssignableFrom(fieldType) && fieldClassType.getParameterCount() == 2) {
            return toPsiClass(fieldClassType.getParameters()[1]);
        } else {
            return toPsiClass(fieldType);
        }
    } else if (fieldType instanceof PsiArrayType) {
        return toPsiClass(((PsiArrayType) fieldType).getComponentType());
    } else {
        return Optional.empty();
    }
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
private SrcType makeSrcType( PsiType type )
{
  SrcType srcType;
  if( type instanceof PsiClassType )
  {
    srcType = new SrcType( ((PsiClassType)type).rawType().getCanonicalText() );
    for( PsiType typeParam : ((PsiClassType)type).getParameters() )
    {
      srcType.addTypeParam( makeSrcType( typeParam ) );
    }
  }
  else
  {
    srcType = new SrcType( type.getCanonicalText() );
  }
  return srcType;
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
public static PsiType maybeInferReturnType( TypeVarToTypeMap inferenceMap, PsiType ownersType, PsiType fromReturnType, PsiType toReturnType )
{
  int iCount = inferenceMap.size();

  PsiType toCompType = toReturnType;
  while( toCompType instanceof PsiArrayType )
  {
    toCompType = ((PsiArrayType)toCompType).getComponentType();
  }
  boolean bTypeVar = isTypeVariable( toCompType );
  if( bTypeVar || isParameterizedType( toCompType ) )
  {
    inferTypeVariableTypesFromGenParamTypeAndConcreteType( toReturnType, fromReturnType, inferenceMap );
    if( bTypeVar && inferenceMap.get( (PsiClassType)toCompType ) != null || inferenceMap.size() > iCount )
    {
      PsiType actualType = getActualType( toReturnType, inferenceMap, false );
      toReturnType = actualType == null ? toReturnType : actualType;
    }
  }
  return replaceTypeVariableTypeParametersWithBoundingTypes( toReturnType, ownersType );
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
public static PsiType makeDefaultParameterizedType( PsiType type )
{
  if( type != null && !isStructuralInterface( type ) &&
      !isParameterizedType( type ) && isGenericType( type ) )
  {
    PsiTypeParameter[] typeVars = type( type ).getTypeParameters();
    PsiType[] boundingTypes = new PsiType[typeVars.length];
    for( int i = 0; i < boundingTypes.length; i++ )
    {
      PsiTypeParameter typeVar = typeVars[i];
      boundingTypes[i] = type( getBoundingType( typeVar ) );
      if( isRecursiveType( (PsiClassType)type( typeVar ), boundingTypes[i] ) )
      {
        return type;
      }
    }

    if( boundingTypes.length == 0 )
    {
      return type;
    }

    type = parameterizeType( (PsiClassType)type, boundingTypes );
  }
  return type;
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
public static PsiType getDefaultParameterizedType( PsiType type, PsiManager mgr )
{
  if( type.getArrayDimensions() > 0 )
  {
    PsiType defType = getDefaultParameterizedType( ((PsiArrayType)type).getComponentType(), mgr );
    if( !defType.equals( type ) )
    {
      return new PsiArrayType( defType );
    }
    return type;
  }
  if( type instanceof PsiIntersectionType )
  {
    return makeDefaultParameterizedTypeForCompoundType( (PsiIntersectionType)type, mgr );
  }
  if( type instanceof PsiDisjunctionType )
  {
    return getDefaultParameterizedType( PsiTypesUtil.getLowestUpperBoundClassType( (PsiDisjunctionType)type ), mgr );
  }
  if( !isGenericType( type ) && !isParameterizedType( type ) )
  {
    return type;
  }
  type = ((PsiClassType)type).rawType();
  return makeDefaultParameterizedType( type );
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
private static PsiType maybeGetLowerBound( PsiWildcardType type, TypeVarToTypeMap actualParamByVarName, boolean bKeepTypeVars, LinkedHashSet<PsiType> recursiveTypes )
{
  PsiType lower = type.getSuperBound();
  if( lower != PsiType.NULL && recursiveTypes.size() > 0 )
  {
    // This is a "super" (contravariant) wildcard

    LinkedList<PsiType> list = new LinkedList<>( recursiveTypes );
    PsiType enclType = list.getLast();
    if( isParameterizedType( enclType ) )
    {
      PsiType genType = getActualType( ((PsiClassType)enclType).rawType(), actualParamByVarName, bKeepTypeVars, recursiveTypes );
      if( LambdaUtil.isFunctionalType( genType ) )
      {
        // For functional interfaces we keep the lower bound as an upper bound so that blocks maintain contravariance wrt the single method's parameters
        return lower;
      }
    }
  }
  return null;
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
private static TypeVarToTypeMap mapActualTypeByVarName( PsiType ownersType )
{
  TypeVarToTypeMap actualParamByVarName = new TypeVarToTypeMap();
  PsiTypeParameter[] vars = type( ownersType ).getTypeParameters();
  if( vars != null )
  {
    PsiType[] paramArgs = ((PsiClassType)ownersType).getParameters();
    for( int i = 0; i < vars.length; i++ )
    {
      PsiClassType typeVar = (PsiClassType)type( vars[i] );
      if( paramArgs.length > i )
      {
        actualParamByVarName.put( typeVar, paramArgs[i] );
      }
    }
  }
  return actualParamByVarName;
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
public JavaCallHierarchyData(PsiClass originalClass,
                             PsiMethod methodToFind,
                             PsiClassType originalType,
                             PsiMethod method,
                             Set<PsiMethod> methodsToFind,
                             NodeDescriptor nodeDescriptor,
                             Map<PsiMember, NodeDescriptor> resultMap,
                             Project project) {

  myOriginalClass = originalClass;
  myMethodToFind = methodToFind;
  myOriginalType = originalType;
  myMethod = method;
  myMethodsToFind = methodsToFind;
  myNodeDescriptor = nodeDescriptor;
  myResultMap = resultMap;
  myProject = project;
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
@Nullable
public static TargetType create(final PsiClassType classType) {
  final PsiClassType.ClassResolveResult resolvedGenerics = classType.resolveGenerics();
  final PsiClass resolvedClass = resolvedGenerics.getElement();
  if (resolvedClass == null) {
    return null;
  }
  final String classQName = resolvedClass.getQualifiedName();
  if (classQName == null) {
    return null;
  }
  if (resolvedClass.hasTypeParameters()) {
    return null;
  }
  return new TargetType(classQName, false, classType);
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
@Override
public void visitVariable(@NotNull PsiVariable variable) {
  super.visitVariable(variable);
  final PsiType type = variable.getType();
  final PsiType componentType = type.getDeepComponentType();
  if (!(componentType instanceof PsiClassType)) {
    return;
  }
  final String className = ((PsiClassType)componentType).getClassName();
  @NonNls final String javaLangReflect = "java.lang.reflect.";
  if (!className.startsWith(javaLangReflect)) {
    return;
  }
  final PsiTypeElement typeElement = variable.getTypeElement();
  if (typeElement == null) {
    return;
  }
  registerError(typeElement);
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
public String getName() {
  PsiType type = psiType;
  if (type instanceof PsiWildcardType) {
    type = ((PsiWildcardType)type).getBound();
  }
  if (type instanceof PsiClassType) {
    final PsiClass resolve = ((PsiClassType)type).resolve();
    if (resolve != null) {
      return resolve.getName();
    }
    final String canonicalText = type.getCanonicalText();
    final int i = canonicalText.indexOf('<');
    if (i < 0) return canonicalText;
    return canonicalText.substring(0, i);
  }

  if (type == null) {
    return "";
  }

  return type.getCanonicalText();
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
@Override
public void getNamedArguments(@NotNull GrCall call,
                              @Nullable PsiElement resolve,
                              @Nullable String argumentName,
                              boolean forCompletion,
                              Map<String, NamedArgumentDescriptor> result) {
  if (!forCompletion || !(resolve instanceof PsiMethod)) return;

  PsiType returnType = ((PsiMethod)resolve).getReturnType();
  if (!(returnType instanceof PsiClassType)) return;

  Map<String, NamedArgumentDescriptor> map = new HashMap<String, NamedArgumentDescriptor>();

  GroovyConstructorNamedArgumentProvider.processClass(call, (PsiClassType)returnType, argumentName, map);

  for (String name : map.keySet()) {
    result.put(name, NamedArgumentDescriptor.SIMPLE_UNLIKELY);
  }
}
 

import com.intellij.psi.PsiClassType; //导入依赖的package包/类
@Override
@NotNull
public PsiJavaCodeReferenceElement[] getReferenceElements() {
  PsiClassType[] types = getReferencedTypes();
  if (types.length == 0) return PsiJavaCodeReferenceElement.EMPTY_ARRAY;

  PsiManagerEx manager = getManager();

  List<PsiJavaCodeReferenceElement> result = ContainerUtil.newArrayList();
  for (PsiClassType type : types) {
    PsiClassType.ClassResolveResult resolveResult = type.resolveGenerics();
    PsiClass resolved = resolveResult.getElement();
    if (resolved != null) {
      result.add(new LightClassReference(manager, type.getCanonicalText(), resolved, resolveResult.getSubstitutor()));
    }
  }
  return result.toArray(new PsiJavaCodeReferenceElement[result.size()]);
}