Java PsiUtil.typeParametersIterable方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
protected PsiClassType calcType() {
  final PsiElement classElement = myClass.getElement();
  if (!(classElement instanceof PsiClass)) return null;
  Map<PsiTypeParameter, PsiType> resurrected = new HashMap<PsiTypeParameter, PsiType>();
  final Set<Map.Entry<SmartPsiElementPointer, SmartTypePointer>> set = myMap.entrySet();
  for (Map.Entry<SmartPsiElementPointer, SmartTypePointer> entry : set) {
    PsiElement element = entry.getKey().getElement();
    if (element instanceof PsiTypeParameter) {
      SmartTypePointer typePointer = entry.getValue();
      resurrected.put((PsiTypeParameter)element, typePointer == null ? null : typePointer.getType());
    }
  }
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable((PsiClass)classElement)) {
    if (!resurrected.containsKey(typeParameter)) {
      resurrected.put(typeParameter, null);
    }
  }
  final PsiSubstitutor resurrectedSubstitutor = PsiSubstitutorImpl.createSubstitutor(resurrected);
  return new PsiImmediateClassType((PsiClass)classElement, resurrectedSubstitutor);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的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.util.PsiUtil; //导入方法依赖的package包/类
@NotNull
@Override
public PsiType getType(PsiElement context, PsiManager manager) throws IncorrectOperationException {
  JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
  PsiElementFactory factory = facade.getElementFactory();

  PsiClass aClass = facade.getResolveHelper().resolveReferencedClass(myClassQName, context);
  if (aClass == null) {
    return factory.createTypeFromText(myClassQName, context);
  }

  Map<PsiTypeParameter, PsiType> substitutionMap = ContainerUtil.newHashMap();
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(aClass)) {
    Type substitute = mySubstitutor.get(typeParameter.getName());
    substitutionMap.put(typeParameter, substitute != null ? substitute.getType(context, manager) : null);
  }
  return factory.createType(aClass, factory.createSubstitutor(substitutionMap), null, myAnnotations);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Override
public Type visitClassType(PsiClassType type) {
  PsiClassType.ClassResolveResult resolveResult = type.resolveGenerics();
  PsiClass aClass = resolveResult.getElement();
  if (aClass instanceof PsiAnonymousClass) {
    return visitClassType(((PsiAnonymousClass)aClass).getBaseClassType());
  }
  else if (aClass == null) {
    return new UnresolvedType(type);
  }
  else {
    Map<String, Type> substitutionMap = ContainerUtil.newHashMap();
    PsiSubstitutor substitutor = resolveResult.getSubstitutor();
    for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(aClass)) {
      PsiType substitute = substitutor.substitute(typeParameter);
      substitutionMap.put(typeParameter.getName(), substitute != null ? substitute.accept(this) : null);
    }
    String qualifiedName = ObjectUtils.notNull(aClass.getQualifiedName(), aClass.getName());
    return new ClassType(type, qualifiedName, substitutionMap);
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
/**
 * Checks if the class type has any parameters which are not unbounded wildcards (and not extends-wildcard with the same bound as corresponding type parameter bound)
 * and do not have substituted arguments.
 *
 * @return true if the class type has nontrivial non-substituted parameters, false otherwise
 */
public boolean hasNonTrivialParameters() {
  final ClassResolveResult resolveResult = resolveGenerics();
  PsiClass aClass = resolveResult.getElement();
  if (aClass == null) return false;
  for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(aClass)) {
    PsiType type = resolveResult.getSubstitutor().substitute(parameter);
    if (type != null) {
      if (!(type instanceof PsiWildcardType)) {
        return true;
      }
      final PsiType bound = ((PsiWildcardType)type).getBound();
      if (bound != null) {
        if (((PsiWildcardType)type).isExtends()) {
          final PsiClass superClass = parameter.getSuperClass();
          if (superClass != null && PsiUtil.resolveClassInType(bound) == superClass) {
            continue;
          }
        }
        return true;
      }
    }
  }
  return false;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static Map<PsiTypeParameter, PsiTypeParameter> calculateReplacementMap(final PsiSubstitutor substitutor,
                                                                        final PsiClass targetClass,
                                                                        final PsiElement containingElement) {
  final HashMap<PsiTypeParameter, PsiTypeParameter> result = new HashMap<PsiTypeParameter, PsiTypeParameter>();
  for (PsiTypeParameter classTypeParameter : PsiUtil.typeParametersIterable(targetClass)) {
    final PsiType substitution = substitutor.substitute(classTypeParameter);
    if (!(substitution instanceof PsiClassType)) return null;
    final PsiClass aClass = ((PsiClassType)substitution).resolve();
    if (!(aClass instanceof PsiTypeParameter)) return null;
    final PsiTypeParameter methodTypeParameter = (PsiTypeParameter)aClass;
    if (methodTypeParameter.getOwner() != containingElement) return null;
    if (result.keySet().contains(methodTypeParameter)) return null;
    result.put(methodTypeParameter, classTypeParameter);
  }
  return result;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@NotNull
@Override
public PsiSubstitutor createRawSubstitutor(@NotNull final PsiTypeParameterListOwner owner) {
  Map<PsiTypeParameter, PsiType> substitutorMap = null;
  for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(owner)) {
    if (substitutorMap == null) substitutorMap = new HashMap<PsiTypeParameter, PsiType>();
    substitutorMap.put(parameter, null);
  }
  return PsiSubstitutorImpl.createSubstitutor(substitutorMap);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private JavaResolveResult advancedResolveImpl(@NotNull PsiFile containingFile) {
  PsiTypeElement[] typeElements = myRefParameterList == null ? PsiTypeElement.EMPTY_ARRAY : myRefParameterList.getTypeParameterElements();
  PsiElement resolve = resolveElement(containingFile);
  if (resolve == null) return null;
  if (resolve instanceof PsiClass) {
    Map<PsiTypeParameter, PsiType> substitutionMap = new HashMap<PsiTypeParameter, PsiType>();
    int index = 0;
    for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable((PsiClass)resolve)) {
      if (index >= typeElements.length) {
        PsiTypeParameterListOwner parameterOwner = parameter.getOwner();
        if (parameterOwner == resolve) {
          substitutionMap.put(parameter, null);
        }
        else if (parameterOwner instanceof PsiClass) {
          PsiElement containingClass = myParent;
          while ((containingClass = PsiTreeUtil.getParentOfType(containingClass, PsiClass.class, true)) != null) {
            PsiSubstitutor superClassSubstitutor =
              TypeConversionUtil.getClassSubstitutor((PsiClass)parameterOwner, (PsiClass)containingClass, PsiSubstitutor.EMPTY);
            if (superClassSubstitutor != null) {
              substitutionMap.put(parameter, superClassSubstitutor.substitute(parameter));
              break;
            }
          }
        }
      }
      else {
        substitutionMap.put(parameter, typeElements[index].getType());
      }
      index++;
    }
    collectOuterClassTypeArgs((PsiClass)resolve, myCanonicalText, substitutionMap);
    return new CandidateInfo(resolve, PsiSubstitutorImpl.createSubstitutor(substitutionMap));
  }
  else {
    return new CandidateInfo(resolve, PsiSubstitutor.EMPTY);
  }
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@NotNull
private static PsiSubstitutor composeSubstitutors(PsiSubstitutor outer, PsiSubstitutor inner, PsiClass onClass) {
  PsiSubstitutor answer = PsiSubstitutor.EMPTY;
  Map<PsiTypeParameter, PsiType> outerMap = outer.getSubstitutionMap();
  Map<PsiTypeParameter, PsiType> innerMap = inner.getSubstitutionMap();
  for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(onClass)) {
    if (outerMap.containsKey(parameter) || innerMap.containsKey(parameter)) {
      answer = answer.put(parameter, outer.substitute(inner.substitute(parameter)));
    }
  }
  return answer;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
/**
 * Checks if the class type has any parameters with no substituted arguments.
 *
 * @return true if the class type has non-substituted parameters, false otherwise
 */
public boolean hasParameters() {
  final ClassResolveResult resolveResult = resolveGenerics();
  PsiClass aClass = resolveResult.getElement();
  if (aClass == null) return false;
  boolean hasParams = false;
  for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(aClass)) {
    if (resolveResult.getSubstitutor().substitute(parameter) == null) return false;
    hasParams = true;
  }
  return hasParams;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
private static PsiSubstitutor getInheritorSubstitutorForNewExpression(final PsiClass baseClass, final PsiClass inheritor,
                                                                     final PsiSubstitutor baseSubstitutor, final PsiElement context) {
  final Project project = baseClass.getProject();
  JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  final PsiResolveHelper resolveHelper = facade.getResolveHelper();
  PsiSubstitutor superSubstitutor = TypeConversionUtil.getClassSubstitutor(baseClass, inheritor, PsiSubstitutor.EMPTY);
  if (superSubstitutor == null) return null;
  PsiSubstitutor inheritorSubstitutor = PsiSubstitutor.EMPTY;
  for (PsiTypeParameter inheritorParameter : PsiUtil.typeParametersIterable(inheritor)) {
    for (PsiTypeParameter baseParameter : PsiUtil.typeParametersIterable(baseClass)) {
      final PsiType substituted = superSubstitutor.substitute(baseParameter);
      PsiType arg = baseSubstitutor.substitute(baseParameter);
      if (arg instanceof PsiWildcardType) arg = ((PsiWildcardType)arg).getBound();
      PsiType substitution =
        resolveHelper.getSubstitutionForTypeParameter(inheritorParameter, substituted, arg, true, PsiUtil.getLanguageLevel(context));
      if (PsiType.NULL.equals(substitution)) continue;
      if (substitution == null) {
        return facade.getElementFactory().createRawSubstitutor(inheritor);
      }
      inheritorSubstitutor = inheritorSubstitutor.put(inheritorParameter, substitution);
      break;
    }
  }

  return inheritorSubstitutor;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
public static PsiSubstitutor inferSubstitutor(final PsiMethod method, final PsiMethodCallExpression callExpr, boolean forCompletion) {
  final PsiResolveHelper helper = JavaPsiFacade.getInstance(method.getProject()).getResolveHelper();
  final PsiParameter[] parameters = method.getParameterList().getParameters();
  PsiExpression[] args = callExpr.getArgumentList().getExpressions();
  PsiSubstitutor result = PsiSubstitutor.EMPTY;
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(method.getContainingClass())) {
    PsiType type = helper.inferTypeForMethodTypeParameter(typeParameter, parameters, args, PsiSubstitutor.EMPTY, callExpr.getParent(),
                                                          forCompletion ? CompletionParameterTypeInferencePolicy.INSTANCE : DefaultParameterTypeInferencePolicy.INSTANCE);
    if (PsiType.NULL.equals(type)) return null;
    result = result.put(typeParameter, type);
  }

  return result;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private PsiMethod createFactoryMethod() throws IncorrectOperationException {
  final PsiClass containingClass = getConstructorContainingClass();
  PsiClassType type = myFactory.createType(containingClass, PsiSubstitutor.EMPTY);
  final PsiMethod factoryMethod = myFactory.createMethod(myFactoryName, type);
  if (myConstructor != null) {
    factoryMethod.getParameterList().replace(myConstructor.getParameterList());
    factoryMethod.getThrowsList().replace(myConstructor.getThrowsList());
  }

  Collection<String> names = new HashSet<String>();
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(myConstructor != null ? myConstructor : containingClass)) {
    if (!names.contains(typeParameter.getName())) { //Otherwise type parameter is hidden in the constructor
      names.add(typeParameter.getName());
      factoryMethod.getTypeParameterList().addAfter(typeParameter, null);
    }
  }

  PsiReturnStatement returnStatement =
    (PsiReturnStatement)myFactory.createStatementFromText("return new A();", null);
  PsiNewExpression newExpression = (PsiNewExpression)returnStatement.getReturnValue();
  PsiJavaCodeReferenceElement classRef = myFactory.createReferenceElementByType(type);
  newExpression.getClassReference().replace(classRef);
  final PsiExpressionList argumentList = newExpression.getArgumentList();

  PsiParameter[] params = factoryMethod.getParameterList().getParameters();

  for (PsiParameter parameter : params) {
    PsiExpression paramRef = myFactory.createExpressionFromText(parameter.getName(), null);
    argumentList.add(paramRef);
  }
  factoryMethod.getBody().add(returnStatement);

  PsiUtil.setModifierProperty(factoryMethod, getDefaultFactoryVisibility(), true);

  if (!myIsInner) {
    PsiUtil.setModifierProperty(factoryMethod, PsiModifier.STATIC, true);
  }

  return (PsiMethod)CodeStyleManager.getInstance(myProject).reformat(factoryMethod);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
@Nullable
public static PsiTypeParameter findTypeParameterInDerived(final PsiClass aClass, final String name) {
  for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(aClass)) {
    if (name.equals(typeParameter.getName())) return typeParameter;
  }

  return null;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static boolean isRaw(PsiType t, final Settings settings, final boolean upper) {
  if (t instanceof PsiClassType) {
    final PsiClassType.ClassResolveResult resolveResult = resolveType(t);

    if (resolveResult.getElement() == null) {
      return false;
    }

    if (PsiClassType.isRaw(resolveResult)) {
      return true;
    }

    final PsiSubstitutor subst = resolveResult.getSubstitutor();
    final PsiClass element = resolveResult.getElement();
    final PsiManager manager = element.getManager();

    if (settings.cookObjects() && upper &&
        t.equals(PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject())))) {
      return true;
    }

    for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(element)) {
      final PsiType actual = subst.substitute(parameter);
      if (isRaw(actual, settings, false)) return true;
    }

    return false;
  }
  else if (t instanceof PsiArrayType) {
    return !settings.preserveRawArrays() && isRaw(((PsiArrayType)t).getComponentType(), settings, upper);
  }

  return false;
}