@Nonnull @CheckReturnValue @Override public PsiType apply(@Nonnull TypeName typeName) { return Stream.of(PrimitiveType.values()) .filter(primitiveType -> primitiveType.isSameAs(typeName)) .map(PrimitiveType::psiType) .findFirst() .orElseGet(() -> PsiType.getJavaLangObject(psiManager, GlobalSearchScope.EMPTY_SCOPE)); }
private PsiCapturedWildcardType(@NotNull PsiWildcardType existential, @NotNull PsiElement context, @Nullable PsiTypeParameter parameter) { super(PsiAnnotation.EMPTY_ARRAY); myExistential = existential; myContext = context; myParameter = parameter; myUpperBound = PsiType.getJavaLangObject(myContext.getManager(), getResolveScope()); }
@Override public PsiType getDefaultExpectedType(PsiCallExpression methodCall) { return PsiType.getJavaLangObject(methodCall.getManager(), methodCall.getResolveScope()); }
@Override public Result<PsiType> compute() { PsiType lub = myTypes.get(0); for (int i = 1; i < myTypes.size(); i++) { lub = GenericsUtil.getLeastUpperBound(lub, myTypes.get(i), myManager); if (lub == null) { lub = PsiType.getJavaLangObject(myManager, GlobalSearchScope.allScope(myManager.getProject())); break; } } return Result.create(lub, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT); } }, false);
/** * @param methodSignature method signature * @param superMethodSignature super method signature * @return null if signatures do not match */ @Nullable public static PsiSubstitutor getSuperMethodSignatureSubstitutor(@NotNull MethodSignature methodSignature, @NotNull MethodSignature superMethodSignature) { PsiSubstitutor result = getSuperMethodSignatureSubstitutorImpl(methodSignature, superMethodSignature); if (result == null) return null; PsiTypeParameter[] methodTypeParameters = methodSignature.getTypeParameters(); PsiTypeParameter[] superTypeParameters = superMethodSignature.getTypeParameters(); PsiSubstitutor methodSubstitutor = methodSignature.getSubstitutor(); //check bounds for (int i = 0; i < methodTypeParameters.length; i++) { PsiTypeParameter methodTypeParameter = methodTypeParameters[i]; PsiTypeParameter superTypeParameter = superTypeParameters[i]; final Set<PsiType> methodSupers = new HashSet<PsiType>(); for (PsiClassType methodSuper : methodTypeParameter.getSuperTypes()) { methodSupers.add(methodSubstitutor.substitute(methodSuper)); } final Set<PsiType> superSupers = new HashSet<PsiType>(); for (PsiClassType superSuper : superTypeParameter.getSuperTypes()) { superSupers.add(methodSubstitutor.substitute(PsiUtil.captureToplevelWildcards(result.substitute(superSuper), methodTypeParameter))); } methodSupers.remove(PsiType.getJavaLangObject(methodTypeParameter.getManager(), methodTypeParameter.getResolveScope())); superSupers.remove(PsiType.getJavaLangObject(superTypeParameter.getManager(), superTypeParameter.getResolveScope())); if (!methodSupers.equals(superSupers)) return null; } return result; }
private static PsiType typeParameterErasure(@NotNull PsiTypeParameter typeParameter, @NotNull PsiSubstitutor beforeSubstitutor) { final PsiClassType[] extendsList = typeParameter.getExtendsList().getReferencedTypes(); if (extendsList.length > 0) { final PsiClass psiClass = extendsList[0].resolve(); if (psiClass instanceof PsiTypeParameter) { Set<PsiClass> visited = new THashSet<PsiClass>(); visited.add(psiClass); final PsiTypeParameter boundTypeParameter = (PsiTypeParameter)psiClass; if (beforeSubstitutor.getSubstitutionMap().containsKey(boundTypeParameter)) { return erasure(beforeSubstitutor.substitute(boundTypeParameter)); } return typeParameterErasureInner(boundTypeParameter, visited, beforeSubstitutor); } else if (psiClass != null) { return JavaPsiFacade.getInstance(typeParameter.getProject()).getElementFactory().createType(psiClass); } } return PsiType.getJavaLangObject(typeParameter.getManager(), typeParameter.getResolveScope()); }
private static PsiClassType typeParameterErasureInner(PsiTypeParameter typeParameter, Set<PsiClass> visited, PsiSubstitutor beforeSubstitutor) { final PsiClassType[] extendsList = typeParameter.getExtendsList().getReferencedTypes(); if (extendsList.length > 0) { final PsiClass psiClass = extendsList[0].resolve(); if (psiClass instanceof PsiTypeParameter) { if (!visited.contains(psiClass)) { visited.add(psiClass); if (beforeSubstitutor.getSubstitutionMap().containsKey(psiClass)) { return (PsiClassType)erasure(beforeSubstitutor.substitute((PsiTypeParameter)psiClass)); } return typeParameterErasureInner((PsiTypeParameter)psiClass, visited, beforeSubstitutor); } } else if (psiClass != null) { return JavaPsiFacade.getInstance(typeParameter.getProject()).getElementFactory().createType(psiClass); } } return PsiType.getJavaLangObject(typeParameter.getManager(), typeParameter.getResolveScope()); }
@Nullable public static PsiType substituteTypeParameter(@Nullable final PsiType psiType, @NotNull final String superClass, final int typeParamIndex, final boolean eraseTypeParameter) { if (psiType == null) return null; if (!(psiType instanceof PsiClassType)) return null; final PsiClassType classType = (PsiClassType)psiType; final PsiClassType.ClassResolveResult classResolveResult = classType.resolveGenerics(); final PsiClass psiClass = classResolveResult.getElement(); if (psiClass == null) return null; final PsiClass baseClass = JavaPsiFacade.getInstance(psiClass.getProject()).findClass(superClass, psiClass.getResolveScope()); if (baseClass == null) return null; if (!psiClass.isEquivalentTo(baseClass) && !psiClass.isInheritor(baseClass, true)) return null; final PsiTypeParameter[] parameters = baseClass.getTypeParameters(); if (parameters.length <= typeParamIndex) return PsiType.getJavaLangObject(psiClass.getManager(), psiClass.getResolveScope()); final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, psiClass, classResolveResult.getSubstitutor()); final PsiType type = substitutor.substitute(parameters[typeParamIndex]); if (type == null && eraseTypeParameter) { return TypeConversionUtil.typeParameterErasure(parameters[typeParamIndex]); } return type; }
PsiClass bClass = classResolveResult2.getElement(); if (aClass == null || bClass == null) { return PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject())); return PsiType.getJavaLangObject(manager, aClass.getResolveScope()); return PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject()));