Java PsiUtil.typeParametersIterator方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private PsiSubstitutor getCallSubstitutor(PsiMethodCallExpression methodCall) {
  JavaResolveResult resolveResult = methodCall.getMethodExpression().advancedResolve(false);
  LOG.assertTrue(myManager.areElementsEquivalent(resolveResult.getElement(), myMethod));
  if (resolveResult.getSubstitutor() != PsiSubstitutor.EMPTY) {
    Iterator<PsiTypeParameter> oldTypeParameters = PsiUtil.typeParametersIterator(myMethod);
    Iterator<PsiTypeParameter> newTypeParameters = PsiUtil.typeParametersIterator(myMethodCopy);
    PsiSubstitutor substitutor = resolveResult.getSubstitutor();
    while (newTypeParameters.hasNext()) {
      final PsiTypeParameter newTypeParameter = newTypeParameters.next();
      final PsiTypeParameter oldTypeParameter = oldTypeParameters.next();
      substitutor = substitutor.put(newTypeParameter, resolveResult.getSubstitutor().substitute(oldTypeParameter));
    }
    return substitutor;
  }

  return PsiSubstitutor.EMPTY;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@NotNull
private static PsiSubstitutor mirrorSubstitutor(@NotNull PsiClass from, @NotNull final PsiClass to, @NotNull PsiSubstitutor substitutor) {
  Iterator<PsiTypeParameter> baseParams = PsiUtil.typeParametersIterator(to);
  Iterator<PsiTypeParameter> candidateParams = PsiUtil.typeParametersIterator(from);

  PsiSubstitutor answer = PsiSubstitutor.EMPTY;
  while (baseParams.hasNext()) {
    // if equivalent classes "from" and "to" have different number of type parameters, then treat "to" as a raw type
    if (!candidateParams.hasNext()) return JavaClassSupersImpl.createRawSubstitutor(to); 

    answer = answer.put(baseParams.next(), substitutor.substitute(candidateParams.next()));
  }
  return answer;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static Boolean isAssignableForNativeTypes(@NotNull PsiType lType,
                                                  @NotNull PsiClassType rType,
                                                  @NotNull PsiElement context) {
  if (!(lType instanceof PsiClassType)) return null;
  final PsiClassType.ClassResolveResult leftResult = ((PsiClassType)lType).resolveGenerics();
  final PsiClassType.ClassResolveResult rightResult = rType.resolveGenerics();
  final PsiClass leftClass = leftResult.getElement();
  PsiClass rightClass = rightResult.getElement();
  if (rightClass == null || leftClass == null) return null;

  if (!InheritanceUtil.isInheritorOrSelf(rightClass, leftClass, true)) return Boolean.FALSE;

  PsiSubstitutor rightSubstitutor = rightResult.getSubstitutor();

  if (!leftClass.hasTypeParameters()) return Boolean.TRUE;
  PsiSubstitutor leftSubstitutor = leftResult.getSubstitutor();

  if (!leftClass.getManager().areElementsEquivalent(leftClass, rightClass)) {
    rightSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(leftClass, rightClass, rightSubstitutor);
    rightClass = leftClass;
  }
  else if (!rightClass.hasTypeParameters()) return Boolean.TRUE;

  Iterator<PsiTypeParameter> li = PsiUtil.typeParametersIterator(leftClass);
  Iterator<PsiTypeParameter> ri = PsiUtil.typeParametersIterator(rightClass);
  while (li.hasNext()) {
    if (!ri.hasNext()) return Boolean.FALSE;
    PsiTypeParameter lp = li.next();
    PsiTypeParameter rp = ri.next();
    final PsiType typeLeft = leftSubstitutor.substitute(lp);
    if (typeLeft == null) continue;
    final PsiType typeRight = rightSubstitutor.substituteWithBoundsPromotion(rp);
    if (typeRight == null) {
      return Boolean.TRUE;
    }
    if (!isAssignableWithoutConversions(typeLeft, typeRight, context)) return Boolean.FALSE;
  }
  return Boolean.TRUE;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static boolean typeParametersAgree(@NotNull PsiClass leftClass,
                                           @NotNull PsiClass rightClass,
                                           @NotNull PsiSubstitutor leftSubstitutor,
                                           @NotNull PsiSubstitutor rightSubstitutor,
                                           @NotNull PsiElement context) {

  if (!leftClass.hasTypeParameters()) return true;

  if (!leftClass.getManager().areElementsEquivalent(leftClass, rightClass)) {
    rightSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(leftClass, rightClass, rightSubstitutor);
    rightClass = leftClass;
  }
  else if (!rightClass.hasTypeParameters()) return true;

  Iterator<PsiTypeParameter> li = PsiUtil.typeParametersIterator(leftClass);
  Iterator<PsiTypeParameter> ri = PsiUtil.typeParametersIterator(rightClass);

  while (li.hasNext()) {
    if (!ri.hasNext()) return false;
    PsiTypeParameter lp = li.next();
    PsiTypeParameter rp = ri.next();
    final PsiType typeLeft = leftSubstitutor.substitute(lp);
    if (typeLeft == null) continue;
    final PsiType typeRight = rightSubstitutor.substituteWithBoundsPromotion(rp);
    if (typeRight == null) {
      // compatibility feature: allow to assign raw types to generic ones
      return true;
    }

    if (typeLeft instanceof PsiClassType && typeRight instanceof PsiClassType) {
      if (!TypesUtil.isAssignableByMethodCallConversion(typeLeft, typeRight, context)) {
        return false;
      }
    }
    else if (!TypeConversionUtil.typesAgree(typeLeft, typeRight, true)) {
      return false;
    }
  }

  return true;
}