@NotNull public PsiType[] getTypes() { return myErrorMessage == null ? myInferredTypes.toArray(createArray(myInferredTypes.size())) : PsiType.EMPTY_ARRAY; }
newConjuncts.add(getLeastUpperBound(type, type2, compared, manager)); return PsiIntersectionType.createIntersection(newConjuncts.toArray(PsiType.createArray(newConjuncts.size())));
public static PsiSubstitutor substituteByParameterName(final PsiClass psiClass, final PsiSubstitutor parentSubstitutor) { final Map<PsiTypeParameter, PsiType> substitutionMap = parentSubstitutor.getSubstitutionMap(); final List<PsiType> result = new ArrayList<PsiType>(substitutionMap.size()); for (PsiTypeParameter typeParameter : psiClass.getTypeParameters()) { final String name = typeParameter.getName(); final PsiTypeParameter key = ContainerUtil.find(substitutionMap.keySet(), new Condition<PsiTypeParameter>() { @Override public boolean value(final PsiTypeParameter psiTypeParameter) { return name.equals(psiTypeParameter.getName()); } }); if (key != null) { result.add(substitutionMap.get(key)); } } return PsiSubstitutor.EMPTY.putAll(psiClass, result.toArray(PsiType.createArray(result.size()))); }
protected MethodSignatureBase(@NotNull PsiSubstitutor substitutor, @NotNull PsiType[] parameterTypes, @NotNull PsiTypeParameter[] typeParameters) { mySubstitutor = substitutor; assert substitutor.isValid(); myParameterTypes = PsiType.createArray(parameterTypes.length); for (int i = 0; i < parameterTypes.length; i++) { PsiType type = parameterTypes[i]; if (type != null) { PsiUtil.ensureValidType(type); } if (type instanceof PsiEllipsisType) type = ((PsiEllipsisType) type).toArrayType(); myParameterTypes[i] = substitutor.substitute(type); } myTypeParameters = typeParameters; }
@NotNull public static PsiType[] calcErasedParameterTypes(@NotNull MethodSignature signature) { PsiType[] parameterTypes = signature.getParameterTypes(); if (parameterTypes.length == 0) return PsiType.EMPTY_ARRAY; PsiSubstitutor substitutor = signature.getSubstitutor(); PsiType[] erasedTypes = PsiType.createArray(parameterTypes.length); for (int i = 0; i < parameterTypes.length; i++) { erasedTypes[i] = TypeConversionUtil.erasure(substitutor.substitute(parameterTypes[i]), substitutor); } return erasedTypes; }
private static PsiType[] getParameterTypes(PsiMethod method) { final PsiParameter[] parameters = method.getParameterList().getParameters(); final PsiType[] paramTypes = PsiType.createArray(parameters.length); for (int i = 0; i < paramTypes.length; i++) { paramTypes[i] = parameters[i].getType(); } return paramTypes; }
protected MethodSignatureBase(@NotNull PsiSubstitutor substitutor, @Nullable PsiParameterList parameterList, @Nullable PsiTypeParameterList typeParameterList) { mySubstitutor = substitutor; if (parameterList == null) { myParameterTypes = PsiType.EMPTY_ARRAY; } else { final PsiParameter[] parameters = parameterList.getParameters(); myParameterTypes = PsiType.createArray(parameters.length); for (int i = 0; i < parameters.length; i++) { PsiType type = parameters[i].getType(); if (type instanceof PsiEllipsisType) type = ((PsiEllipsisType)type).toArrayType(); myParameterTypes[i] = substitutor.substitute(type); } } myTypeParameters = typeParameterList == null ? PsiTypeParameter.EMPTY_ARRAY : typeParameterList.getTypeParameters(); }
@NotNull public static MethodSignatureBackedByPsiMethod create(@NotNull PsiMethod method, @NotNull PsiSubstitutor substitutor, boolean isRaw) { PsiTypeParameter[] methodTypeParameters = method.getTypeParameters(); if (isRaw) { substitutor = JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createRawSubstitutor(substitutor, methodTypeParameters); methodTypeParameters = PsiTypeParameter.EMPTY_ARRAY; } assert substitutor.isValid(); final PsiParameter[] parameters = method.getParameterList().getParameters(); PsiType[] parameterTypes = PsiType.createArray(parameters.length); for (int i = 0; i < parameterTypes.length; i++) { PsiParameter parameter = parameters[i]; PsiType type = parameter.getType(); parameterTypes[i] = isRaw ? TypeConversionUtil.erasure(substitutor.substitute(type)) : type; if (!parameterTypes[i].isValid()) { PsiUtil.ensureValidType(parameterTypes[i], "Method " + method + " of " + method.getClass() + "; param " + parameter + " of " + parameter.getClass()); } } return new MethodSignatureBackedByPsiMethod(method, substitutor, isRaw, parameterTypes, methodTypeParameters); } }