Java PsiUtil.substituteTypeParameter方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static PsiType getEntryForMap(@Nullable PsiType map, @NotNull final Project project, @NotNull final GlobalSearchScope scope) {
  PsiType key = PsiUtil.substituteTypeParameter(map, JAVA_UTIL_MAP, 0, true);
  PsiType value = PsiUtil.substituteTypeParameter(map, JAVA_UTIL_MAP, 1, true);

  final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
  final PsiClass entryClass = JavaPsiFacade.getInstance(project).findClass(JAVA_UTIL_MAP_ENTRY, scope);
  if (entryClass == null) {
    if (key != null && key != PsiType.NULL && value != null && value != PsiType.NULL) {
      final String text = String.format("%s<%s,%s>", JAVA_UTIL_MAP_ENTRY, key.getCanonicalText(), value.getCanonicalText());
      return factory.createTypeFromText(text, null);
    }
    else {
      return factory.createTypeByFQClassName(JAVA_UTIL_MAP_ENTRY, scope);
    }
  }
  else {
    return factory.createType(entryClass, key, value);
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
static void addCollectConversion(PsiReferenceExpression ref, Collection<ExpectedTypeInfo> expectedTypes, Consumer<LookupElement> consumer) {
  final PsiExpression qualifier = ref.getQualifierExpression();
  PsiType component = qualifier == null ? null : PsiUtil.substituteTypeParameter(qualifier.getType(), JAVA_UTIL_STREAM_STREAM, 0, true);
  if (component == null) return;

  JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject());
  GlobalSearchScope scope = ref.getResolveScope();
  PsiClass list = facade.findClass(JAVA_UTIL_LIST, scope);
  PsiClass set = facade.findClass(JAVA_UTIL_SET, scope);
  if (facade.findClass(JAVA_UTIL_STREAM_COLLECTORS, scope) == null || list == null || set == null) return;

  boolean hasList = false;
  boolean hasSet = false;
  for (ExpectedTypeInfo info : expectedTypes) {
    PsiType type = info.getDefaultType();
    PsiClass expectedClass = PsiUtil.resolveClassInClassTypeOnly(type);
    PsiType expectedComponent = PsiUtil.extractIterableTypeParameter(type, true);
    if (expectedClass == null || expectedComponent == null || !TypeConversionUtil.isAssignable(expectedComponent, component)) continue;

    if (!hasList && InheritanceUtil.isInheritorOrSelf(list, expectedClass, true)) {
      hasList = true;
      consumer.consume(new MyLookupElement("toList", type));
    }

    if (!hasSet && InheritanceUtil.isInheritorOrSelf(set, expectedClass, true)) {
      hasSet = true;
      consumer.consume(new MyLookupElement("toSet", type));
    }

  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
public static void addCompletions(@NotNull final JavaSmartCompletionParameters parameters,
                                  @NotNull Consumer<LookupElement> result, final PrefixMatcher matcher) {
  PsiType expectedType = parameters.getDefaultType();
  if (!InheritanceUtil.isInheritor(expectedType, CommonClassNames.JAVA_LANG_CLASS)) {
    expectedType = parameters.getExpectedType();
    if (!InheritanceUtil.isInheritor(expectedType, CommonClassNames.JAVA_LANG_CLASS)) {
      return;
    }
  }

  PsiType classParameter = PsiUtil.substituteTypeParameter(expectedType, CommonClassNames.JAVA_LANG_CLASS, 0, false);

  boolean addInheritors = false;
  PsiElement position = parameters.getPosition();
  if (classParameter instanceof PsiWildcardType) {
    final PsiWildcardType wildcardType = (PsiWildcardType)classParameter;
    classParameter = wildcardType.isSuper() ? wildcardType.getSuperBound() : wildcardType.getExtendsBound();
    addInheritors = wildcardType.isExtends() && classParameter instanceof PsiClassType;
  } else if (!matcher.getPrefix().isEmpty()) {
    addInheritors = true;
    classParameter = PsiType.getJavaLangObject(position.getManager(), position.getResolveScope());
  }
  if (classParameter != null) {
    PsiFile file = position.getContainingFile();
    addClassLiteralLookupElement(classParameter, result, file);
    if (addInheritors) {
      addInheritorClassLiterals(file, classParameter, result, matcher);
    }
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static PsiClass resolveExtensionPointClass(PsiField psiField) {
  final PsiType typeParameter = PsiUtil.substituteTypeParameter(psiField.getType(),
                                                                ExtensionPointName.class.getName(),
                                                                0, false);
  return PsiUtil.resolveClassInClassTypeOnly(typeParameter);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public void visitBinaryExpression(GrBinaryExpression expression) {
  super.visitBinaryExpression(expression);

  if (expression.getOperationTokenType() != GroovyTokenTypes.kIN) return;

  GrExpression leftOperand = expression.getLeftOperand();
  GrExpression rightOperand = expression.getRightOperand();
  if (rightOperand == null) return;

  PsiType ltype = leftOperand.getType();
  PsiType rtype = rightOperand.getType();
  if (ltype == null || rtype == null) return;

  PsiType component;

  if (rtype instanceof PsiArrayType) {
    component = ((PsiArrayType)rtype).getComponentType();
  }
  else if (InheritanceUtil.isInheritor(rtype, CommonClassNames.JAVA_UTIL_COLLECTION)) {
    component = PsiUtil.substituteTypeParameter(rtype, CommonClassNames.JAVA_UTIL_COLLECTION, 0, false);
  }
  else {
    checkSimpleClasses(ltype, rtype, expression);
    return;
  }

  if (component == null) return;
  
  if (TypesUtil.isAssignableWithoutConversions(component, ltype, expression)) return;

  registerError(expression, ltype, rtype);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@NotNull
@Override
public List<PsiType[]> inferExpectedSignatures(@NotNull PsiMethod method,
                                               @NotNull PsiSubstitutor substitutor,
                                               @NotNull String[] options) {
  int argNum = extractArgNum(options);
  boolean index = extractIndex(options);

  PsiParameter[] parameters = method.getParameterList().getParameters();

  if (argNum >= parameters.length) return ContainerUtil.emptyList();

  PsiParameter parameter = parameters[argNum];
  PsiType type = parameter.getType();
  PsiType substituted = substitutor.substitute(type);

  if (!InheritanceUtil.isInheritor(substituted, CommonClassNames.JAVA_UTIL_MAP)) return ContainerUtil.emptyList();

  PsiType key = PsiUtil.substituteTypeParameter(substituted, CommonClassNames.JAVA_UTIL_MAP, 0, true);
  PsiType value = PsiUtil.substituteTypeParameter(substituted, CommonClassNames.JAVA_UTIL_MAP, 1, true);

  PsiClass mapEntry = JavaPsiFacade.getInstance(method.getProject()).findClass(CommonClassNames.JAVA_UTIL_MAP_ENTRY, method.getResolveScope());
  if (mapEntry == null) return ContainerUtil.emptyList();

  PsiClassType mapEntryType = JavaPsiFacade.getElementFactory(method.getProject()).createType(mapEntry, key, value);

  PsiType[] keyValueSignature = index ? new PsiType[]{key, value, PsiType.INT} : new PsiType[]{key, value};
  PsiType[] mapEntrySignature = index ? new PsiType[]{mapEntryType, PsiType.INT} : new PsiType[]{mapEntryType};

  return ContainerUtil.newArrayList(keyValueSignature, mapEntrySignature);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static PsiType findTypeFromIteratorMethod(@Nullable PsiType type, PsiElement context) {
  if (!(type instanceof PsiClassType)) return null;

  final GroovyResolveResult[] candidates = ResolveUtil.getMethodCandidates(type, "iterator", context, PsiType.EMPTY_ARRAY);
  final GroovyResolveResult candidate = PsiImplUtil.extractUniqueResult(candidates);
  final PsiElement element = candidate.getElement();
  if (!(element instanceof PsiMethod)) return null;

  final PsiType returnType = org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.getSmartReturnType((PsiMethod)element);
  final PsiType iteratorType = candidate.getSubstitutor().substitute(returnType);

  return PsiUtil.substituteTypeParameter(iteratorType, JAVA_UTIL_ITERATOR, 0, false);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static boolean processTypesFromTuple(@NotNull GrTupleType type,
                                             @NotNull PsiScopeProcessor processor,
                                             @NotNull ResolveState state,
                                             @NotNull GrClosableBlock place) {
  for (PsiType component : type.getComponentTypes()) {
    PsiType clazz = PsiUtil.substituteTypeParameter(component, CommonClassNames.JAVA_LANG_CLASS, 0, false);
    PsiClass aClass = PsiTypesUtil.getPsiClass(clazz);
    if (aClass != null) {
      if (!processCategoryMethods(place, processor, state, aClass)) return false;
    }
  }
  return true;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static PsiType genNewMapBy(PsiType genericOwner, PsiManager manager) {
  PsiClass map = JavaPsiFacade.getInstance(manager.getProject()).findClass(CommonClassNames.JAVA_UTIL_MAP, genericOwner.getResolveScope());
  PsiElementFactory factory = JavaPsiFacade.getElementFactory(manager.getProject());
  if (map == null) return factory.createTypeFromText(CommonClassNames.JAVA_UTIL_MAP, null);

  final PsiType key = PsiUtil.substituteTypeParameter(genericOwner, CommonClassNames.JAVA_UTIL_MAP, 0, false);
  final PsiType value = PsiUtil.substituteTypeParameter(genericOwner, CommonClassNames.JAVA_UTIL_MAP, 1, false);
  return factory.createType(map, key, value);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
@Override
protected PsiType calculateReturnType(@NotNull GrMethodCall callExpression, @NotNull PsiMethod resolvedMethod) {
  if (!"withTraits".equals(resolvedMethod.getName())) return null;

  if (resolvedMethod instanceof GrGdkMethod) {
    resolvedMethod = ((GrGdkMethod)resolvedMethod).getStaticMethod();
  }

  GrExpression invokedExpression = callExpression.getInvokedExpression();
  if (!(invokedExpression instanceof GrReferenceExpression)) return null;
  GrExpression originalObject = ((GrReferenceExpression)invokedExpression).getQualifierExpression();
  if (originalObject == null) return null;

  PsiType invokedType = originalObject.getType();
  if (!(invokedType instanceof PsiClassType)) return null;

  PsiClass containingClass = resolvedMethod.getContainingClass();
  if (containingClass == null || !GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(containingClass.getQualifiedName())) return null;

  List<PsiClassType> traits = ContainerUtil.newArrayList();
  GrExpression[] args = callExpression.getArgumentList().getExpressionArguments();
  for (GrExpression arg : args) {
    PsiType type = arg.getType();
    PsiType classItem = PsiUtil.substituteTypeParameter(type, CommonClassNames.JAVA_LANG_CLASS, 0, false);
    PsiClass psiClass = PsiTypesUtil.getPsiClass(classItem);
    if (GrTraitUtil.isTrait(psiClass)) {
      traits.add((PsiClassType)classItem);
    }
  }

  return GrTraitType.createTraitClassType(callExpression, (PsiClassType)invokedType, traits, callExpression.getResolveScope());
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static PsiType getStreamComponentType(PsiType expectedType) {
  return PsiUtil.substituteTypeParameter(expectedType, CommonClassNames.JAVA_UTIL_STREAM_BASE_STREAM, 0, true);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static PsiType extractComponentType(PsiType type) {
  if (type instanceof PsiArrayType) return ((PsiArrayType)type).getComponentType();
  return PsiUtil.substituteTypeParameter(type, CommonClassNames.JAVA_UTIL_COLLECTION, 0, false);
}