public static PsiClassType getClassType(@NotNull PsiClass psiClass) { return JavaPsiFacade.getElementFactory(psiClass.getProject()).createType(psiClass); }
conjuncts[i] = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(aSuper, substitutor);
public static boolean isReceiverType(@Nullable PsiType receiverType, PsiClass containingClass, PsiSubstitutor psiSubstitutor) { if (receiverType == null) { return false; } return TypeConversionUtil.isAssignable(JavaPsiFacade.getElementFactory(containingClass.getProject()).createType(containingClass, psiSubstitutor), replaceArrayType(receiverType, containingClass)); }
@Nullable private static PsiSubstitutor getSuperMethodSignatureSubstitutorImpl(@NotNull MethodSignature methodSignature, @NotNull MethodSignature superSignature) { // normalize generic method declarations: correlate type parameters // todo: correlate type params by name? PsiTypeParameter[] methodTypeParameters = methodSignature.getTypeParameters(); PsiTypeParameter[] superTypeParameters = superSignature.getTypeParameters(); // both methods are parameterized and number of parameters mismatch if (methodTypeParameters.length != superTypeParameters.length) return null; PsiSubstitutor result = superSignature.getSubstitutor(); for (int i = 0; i < methodTypeParameters.length; i++) { PsiTypeParameter methodTypeParameter = methodTypeParameters[i]; PsiElementFactory factory = JavaPsiFacade.getInstance(methodTypeParameter.getProject()).getElementFactory(); result = result.put(superTypeParameters[i], factory.createType(methodTypeParameter)); } return result; }
@NotNull private static PsiClassType obtainSafeSuperType(@NotNull PsiTypeParameter typeParameter) { final PsiClassType superType = typeParameter.getSuperTypes()[0]; final PsiClassType.ClassResolveResult result = superType.resolveGenerics(); final PsiClass superClass = result.getElement(); if (superClass != null) { final PsiSubstitutor substitutor = result.getSubstitutor().put(typeParameter, null); return JavaPsiFacade.getInstance(typeParameter.getProject()).getElementFactory().createType(superClass, substitutor); } return superType; }
@Nullable public PsiClassType getBoxedType(final PsiManager manager, final GlobalSearchScope resolveScope) { final String boxedQName = getBoxedTypeName(); //[ven]previous call returns null for NULL, VOID if (boxedQName == null) return null; final PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(boxedQName, resolveScope); if (aClass == null) return null; return JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(aClass); }
@Nullable public static PsiType createJavaLangClassType(@NotNull PsiElement context, @Nullable PsiType qualifierType, boolean captureTopLevelWildcards) { if (qualifierType != null) { PsiUtil.ensureValidType(qualifierType); JavaPsiFacade facade = JavaPsiFacade.getInstance(context.getProject()); PsiClass javaLangClass = facade.findClass(CommonClassNames.JAVA_LANG_CLASS, context.getResolveScope()); if (javaLangClass != null && javaLangClass.getTypeParameters().length == 1) { PsiSubstitutor substitutor = PsiSubstitutor.EMPTY. put(javaLangClass.getTypeParameters()[0], PsiWildcardType.createExtends(context.getManager(), qualifierType)); final PsiClassType classType = facade.getElementFactory().createType(javaLangClass, substitutor, PsiUtil.getLanguageLevel(context)); return captureTopLevelWildcards ? PsiUtil.captureToplevelWildcards(classType, context) : classType; } } return null; }
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()); }
public static PsiType patchMethodGetClassReturnType(@NotNull PsiExpression call, @NotNull PsiReferenceExpression methodExpression, @NotNull PsiMethod method, @Nullable Condition<IElementType> condition, @NotNull LanguageLevel languageLevel) { //JLS3 15.8.2 if (languageLevel.isAtLeast(LanguageLevel.JDK_1_5) && isGetClass(method)) { PsiExpression qualifier = methodExpression.getQualifierExpression(); PsiType qualifierType = null; final Project project = call.getProject(); if (qualifier != null) { qualifierType = TypeConversionUtil.erasure(qualifier.getType()); } else if (condition != null) { ASTNode parent = call.getNode().getTreeParent(); while (parent != null && condition.value(parent.getElementType())) { parent = parent.getTreeParent(); } if (parent != null) { qualifierType = JavaPsiFacade.getInstance(project).getElementFactory().createType((PsiClass)parent.getPsi()); } } return createJavaLangClassType(methodExpression, qualifierType, true); } return null; }
@Nullable public static PsiType getQualifierType(PsiMethodReferenceExpression expression) { PsiType qualifierType = null; final PsiTypeElement typeElement = expression.getQualifierType(); if (typeElement != null) { qualifierType = typeElement.getType(); } else { final PsiElement qualifier = expression.getQualifier(); if (qualifier instanceof PsiExpression) { qualifierType = ((PsiExpression)qualifier).getType(); } } if (qualifierType == null) { final QualifierResolveResult qualifierResolveResult = getQualifierResolveResult(expression); final PsiClass containingClass = qualifierResolveResult.getContainingClass(); if (containingClass == null) { return null; } qualifierType = JavaPsiFacade.getElementFactory(expression.getProject()).createType(containingClass); } return qualifierType; }
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()); }
try { PsiMethod setMethod = factory .createMethodFromText(factory.createMethod(setName, returnSelf ? factory.createType(containingClass) : PsiType.VOID).getText(), field); String parameterName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
/** * Returns a boxed class type corresponding to the primitive type. * * @param context where this boxed type is to be used * @return the class type, or null if the current language level does not support autoboxing or * it was not possible to resolve the reference to the class. */ @Nullable public PsiClassType getBoxedType(PsiElement context) { LanguageLevel languageLevel = PsiUtil.getLanguageLevel(context); if (!languageLevel.isAtLeast(LanguageLevel.JDK_1_5)) return null; String boxedQName = getBoxedTypeName(); //[ven]previous call returns null for NULL, VOID if (boxedQName == null) return null; PsiClass aClass = JavaPsiFacade.getInstance(context.getProject()).findClass(boxedQName, context.getResolveScope()); if (aClass == null) return null; PsiElementFactory factory = JavaPsiFacade.getInstance(context.getProject()).getElementFactory(); return factory.createType(aClass, PsiSubstitutor.EMPTY, languageLevel, getAnnotations()); }
final PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); final PsiSubstitutor newSubstitutor = factory.createSubstitutor(substitutionMap); return factory.createType(aClass, newSubstitutor);
PsiClassType type = factory.createType(exceptionClass); ref1 = factory.createReferenceElementByType(type); PsiClassType type = factory.createType(exceptionClass); ref = factory.createReferenceElementByType(type);
final PsiClassType boundType = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(nestedLayer, subst); return PsiWildcardType.createExtends(manager, boundType);
type = factory.createType(aClass, substitutor);
if (interfaceReturnType != null && interfaceReturnType != PsiType.VOID) { if (methodReturnType == null) { methodReturnType = JavaPsiFacade.getElementFactory(expression.getProject()).createType(containingClass, subst);
PsiManager manager = aClass.getManager(); PsiType result = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory() .createType(aClass, substitutor, PsiUtil.getLanguageLevel(aClass), applicableAnnotations); if (toExtend) result = PsiWildcardType.createExtends(manager, result); return result;
PsiClass containingClass = enumConstant.getContainingClass(); final JavaPsiFacade facade = JavaPsiFacade.getInstance(enumConstant.getProject()); final PsiClassType type = facade.getElementFactory().createType(containingClass); final JavaResolveResult newResult = facade.getResolveHelper().resolveConstructor(type, newCall.getArgumentList(), enumConstant); if (oldMethod.equals(newResult.getElement()) && newResult.isValidResult()) {