private JavaResolveResult advancedResolveInner(final PsiElement psiElement, final String qName) {
final PsiManager manager = psiElement.getManager();
final GlobalSearchScope scope = getScope();
if (myIndex == myJavaClassReferenceSet.getReferences().length - 1) {
final PsiClass aClass =
JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, scope);
if (aClass != null) {
return new ClassCandidateInfo(aClass, PsiSubstitutor.EMPTY, false, psiElement);
} else {
if (!JavaClassReferenceProvider.ADVANCED_RESOLVE.getBooleanValue(getOptions())) {
return JavaResolveResult.EMPTY;
}
}
}
PsiElement resolveResult = JavaPsiFacade.getInstance(manager.getProject()).findPackage(qName);
if (resolveResult == null) {
resolveResult = JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, scope);
}
if (myInStaticImport && resolveResult == null) {
resolveResult = resolveMember(qName, manager, getElement().getResolveScope());
}
if (resolveResult == null) {
PsiFile containingFile = psiElement.getContainingFile();
if (containingFile instanceof PsiJavaFile) {
if (containingFile instanceof JspFile) {
containingFile = containingFile.getViewProvider().getPsi(StdLanguages.JAVA);
if (containingFile == null) return JavaResolveResult.EMPTY;
}
final ClassResolverProcessor processor =
new ClassResolverProcessor(getCanonicalText(), psiElement);
containingFile.processDeclarations(processor, ResolveState.initial(), null, psiElement);
if (processor.getResult().length == 1) {
final JavaResolveResult javaResolveResult = processor.getResult()[0];
if (javaResolveResult != JavaResolveResult.EMPTY && getOptions() != null) {
final Boolean value =
JavaClassReferenceProvider.RESOLVE_QUALIFIED_CLASS_NAME.getValue(getOptions());
final PsiClass psiClass = (PsiClass) javaResolveResult.getElement();
if (value != null && value.booleanValue() && psiClass != null) {
final String qualifiedName = psiClass.getQualifiedName();
if (!qName.equals(qualifiedName)) {
return JavaResolveResult.EMPTY;
}
}
}
return javaResolveResult;
}
}
}
return resolveResult != null
? new CandidateInfo(resolveResult, PsiSubstitutor.EMPTY, false, false, psiElement)
: JavaResolveResult.EMPTY;
}
@Nullable
public static PsiClass getBaseClass(GrTypeDefinition grType) {
if (grType.isEnum()) {
return JavaPsiFacade.getInstance(grType.getProject())
.findClass(CommonClassNames.JAVA_LANG_ENUM, grType.getResolveScope());
} else {
return JavaPsiFacade.getInstance(grType.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, grType.getResolveScope());
}
}
@NotNull
private static PsiClass[] getSupersInner(@NotNull PsiClass psiClass) {
PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
if (psiClass.isInterface()) {
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), true);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiAnonymousClass psiAnonymousClass = (PsiAnonymousClass) psiClass;
PsiClassType baseClassReference = psiAnonymousClass.getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass != null) {
if (baseClass.isInterface()) {
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null
? new PsiClass[] {objectClass, baseClass}
: new PsiClass[] {baseClass};
}
return new PsiClass[] {baseClass};
}
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
if (psiClass instanceof PsiTypeParameter) {
if (extendsListTypes.length == 0) {
final PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
}
PsiClass[] interfaces =
resolveClassReferenceList(
implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
PsiClass superClass = getSuperClass(psiClass);
if (superClass == null) return interfaces;
PsiClass[] types = new PsiClass[interfaces.length + 1];
types[0] = superClass;
System.arraycopy(interfaces, 0, types, 1, interfaces.length);
return types;
}
@Nullable
public static PsiElement resolveMember(
String fqn, PsiManager manager, GlobalSearchScope resolveScope) {
PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(fqn, resolveScope);
if (aClass != null) return aClass;
int i = fqn.lastIndexOf('.');
if (i == -1) return null;
String memberName = fqn.substring(i + 1);
fqn = fqn.substring(0, i);
aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(fqn, resolveScope);
if (aClass == null) return null;
return doResolveMember(aClass, memberName);
}
@Nullable
public static PsiClass getSuperClass(@NotNull PsiClass psiClass) {
PsiManager manager = psiClass.getManager();
GlobalSearchScope resolveScope = psiClass.getResolveScope();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
if (psiClass.isInterface()) {
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
}
if (psiClass.isEnum()) {
return facade.findClass(CommonClassNames.JAVA_LANG_ENUM, resolveScope);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiClassType baseClassReference = ((PsiAnonymousClass) psiClass).getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass == null || baseClass.isInterface())
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
return baseClass;
}
if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return null;
final PsiClassType[] referenceElements = psiClass.getExtendsListTypes();
if (referenceElements.length == 0)
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
PsiClass psiResoved = referenceElements[0].resolve();
return psiResoved == null
? facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope)
: psiResoved;
}
@Nullable
private static PsiType getTypeFromMapAccess(@NotNull GrReferenceExpression ref) {
// map access
GrExpression qualifier = ref.getQualifierExpression();
if (qualifier instanceof GrReferenceExpression) {
if (((GrReferenceExpression) qualifier).resolve() instanceof PsiClass) return null;
}
if (qualifier != null) {
PsiType qType = qualifier.getType();
if (qType instanceof PsiClassType) {
PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics();
PsiClass clazz = qResult.getElement();
if (clazz != null) {
PsiClass mapClass =
JavaPsiFacade.getInstance(ref.getProject())
.findClass(CommonClassNames.JAVA_UTIL_MAP, ref.getResolveScope());
if (mapClass != null && mapClass.getTypeParameters().length == 2) {
PsiSubstitutor substitutor =
TypeConversionUtil.getClassSubstitutor(mapClass, clazz, qResult.getSubstitutor());
if (substitutor != null) {
PsiType substituted = substitutor.substitute(mapClass.getTypeParameters()[1]);
if (substituted != null) {
return PsiImplUtil.normalizeWildcardTypeByPosition(substituted, ref);
}
}
}
}
}
}
return null;
}
public static boolean inheritsITestListener(@NotNull PsiClass psiClass) {
final Project project = psiClass.getProject();
final PsiClass aListenerClass =
JavaPsiFacade.getInstance(project)
.findClass(ITestNGListener.class.getName(), GlobalSearchScope.allScope(project));
return aListenerClass != null && psiClass.isInheritor(aListenerClass, true);
}
private Object[] processPackage(final PsiPackage aPackage) {
final ArrayList<Object> list = new ArrayList<Object>();
final int startOffset =
StringUtil.isEmpty(aPackage.getName()) ? 0 : aPackage.getQualifiedName().length() + 1;
final GlobalSearchScope scope = getScope();
for (final PsiPackage subPackage : aPackage.getSubPackages(scope)) {
final String shortName = subPackage.getQualifiedName().substring(startOffset);
if (JavaPsiFacade.getInstance(subPackage.getProject())
.getNameHelper()
.isIdentifier(shortName)) {
list.add(subPackage);
}
}
final PsiClass[] classes = aPackage.getClasses(scope);
final Map<CustomizableReferenceProvider.CustomizationKey, Object> options = getOptions();
if (options != null) {
final boolean instantiatable =
JavaClassReferenceProvider.INSTANTIATABLE.getBooleanValue(options);
final boolean concrete = JavaClassReferenceProvider.CONCRETE.getBooleanValue(options);
final boolean notInterface =
JavaClassReferenceProvider.NOT_INTERFACE.getBooleanValue(options);
final boolean notEnum = JavaClassReferenceProvider.NOT_ENUM.getBooleanValue(options);
final ClassKind classKind = getClassKind();
for (PsiClass clazz : classes) {
if (isClassAccepted(clazz, classKind, instantiatable, concrete, notInterface, notEnum)) {
list.add(clazz);
}
}
} else {
ContainerUtil.addAll(list, classes);
}
return list.toArray();
}
@NotNull
private static PsiClass[] resolveClassReferenceList(
@NotNull PsiClassType[] listOfTypes,
@NotNull PsiManager manager,
@NotNull GlobalSearchScope resolveScope,
boolean includeObject) {
PsiClass objectClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
if (objectClass == null) includeObject = false;
if (listOfTypes.length == 0) {
if (includeObject) return new PsiClass[] {objectClass};
return PsiClass.EMPTY_ARRAY;
}
int referenceCount = listOfTypes.length;
if (includeObject) referenceCount++;
PsiClass[] resolved = new PsiClass[referenceCount];
int resolvedCount = 0;
if (includeObject) resolved[resolvedCount++] = objectClass;
for (PsiClassType reference : listOfTypes) {
PsiClass refResolved = reference.resolve();
if (refResolved != null) resolved[resolvedCount++] = refResolved;
}
if (resolvedCount < referenceCount) {
PsiClass[] shorter = new PsiClass[resolvedCount];
System.arraycopy(resolved, 0, shorter, 0, resolvedCount);
resolved = shorter;
}
return resolved;
}
public static boolean isValidPropertyReference(
@NotNull Project project,
@NotNull PsiLiteralExpression expression,
@NotNull String key,
@NotNull Ref<String> outResourceBundle) {
final HashMap<String, Object> annotationAttributeValues = new HashMap<String, Object>();
annotationAttributeValues.put(AnnotationUtil.PROPERTY_KEY_RESOURCE_BUNDLE_PARAMETER, null);
if (mustBePropertyKey(project, expression, annotationAttributeValues)) {
final Object resourceBundleName =
annotationAttributeValues.get(AnnotationUtil.PROPERTY_KEY_RESOURCE_BUNDLE_PARAMETER);
if (!(resourceBundleName instanceof PsiExpression)) {
return false;
}
PsiExpression expr = (PsiExpression) resourceBundleName;
final Object value =
JavaPsiFacade.getInstance(expr.getProject())
.getConstantEvaluationHelper()
.computeConstantExpression(expr);
if (value == null) {
return false;
}
String bundleName = value.toString();
outResourceBundle.set(bundleName);
return isPropertyRef(expression, key, bundleName);
}
return true;
}
@NotNull
public static PsiClassType[] getExtendsListTypes(GrTypeDefinition grType) {
final PsiClassType[] extendsTypes = getReferenceListTypes(grType.getExtendsClause());
if (grType.isInterface()) {
return extendsTypes;
}
for (PsiClassType type : extendsTypes) {
final PsiClass superClass = type.resolve();
if (superClass instanceof GrTypeDefinition && !superClass.isInterface()
|| superClass != null
&& GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT.equals(
superClass.getQualifiedName())) {
return extendsTypes;
}
}
PsiClass grObSupport =
GroovyPsiManager.getInstance(grType.getProject())
.findClassWithCache(
GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT, grType.getResolveScope());
if (grObSupport != null) {
final PsiClassType type =
JavaPsiFacade.getInstance(grType.getProject())
.getElementFactory()
.createType(grObSupport);
return ArrayUtil.append(extendsTypes, type, PsiClassType.ARRAY_FACTORY);
}
return extendsTypes;
}
@Nullable
public PsiPackage getPsiElement() {
final String qualifiedName = data.getPackageName();
return qualifiedName != null
? JavaPsiFacade.getInstance(getProject()).findPackage(qualifiedName)
: null;
}
@Nullable
public static PsiClass findActivityClass(@NotNull Module module) {
return JavaPsiFacade.getInstance(module.getProject())
.findClass(
AndroidUtils.ACTIVITY_BASE_CLASS_NAME,
module.getModuleWithDependenciesAndLibrariesScope(false));
}
private void fixReferencesToStatic(PsiElement classMember) throws IncorrectOperationException {
final StaticReferencesCollector collector = new StaticReferencesCollector();
classMember.accept(collector);
ArrayList<PsiJavaCodeReferenceElement> refs = collector.getReferences();
ArrayList<PsiElement> members = collector.getReferees();
ArrayList<PsiClass> classes = collector.getRefereeClasses();
PsiElementFactory factory =
JavaPsiFacade.getInstance(classMember.getProject()).getElementFactory();
for (int i = 0; i < refs.size(); i++) {
PsiJavaCodeReferenceElement ref = refs.get(i);
PsiElement namedElement = members.get(i);
PsiClass aClass = classes.get(i);
if (namedElement instanceof PsiNamedElement) {
PsiReferenceExpression newRef =
(PsiReferenceExpression)
factory.createExpressionFromText(
"a." + ((PsiNamedElement) namedElement).getName(), null);
PsiExpression qualifierExpression = newRef.getQualifierExpression();
assert qualifierExpression != null;
qualifierExpression =
(PsiExpression) qualifierExpression.replace(factory.createReferenceExpression(aClass));
qualifierExpression.putCopyableUserData(PRESERVE_QUALIFIER, ref.isQualified());
ref.replace(newRef);
}
}
}
protected CompleteReferenceProcessor() {
super(null, EnumSet.allOf(ResolveKind.class), myRefExpr, PsiType.EMPTY_ARRAY);
myConsumer =
new Consumer<LookupElement>() {
@Override
public void consume(LookupElement element) {
myIsEmpty = false;
CompleteReferenceExpression.this.myConsumer.consume(element);
}
};
myPreferredFieldNames = addAllRestrictedProperties();
mySkipPackages = shouldSkipPackages();
myEventListener =
JavaPsiFacade.getInstance(myRefExpr.getProject())
.findClass("java.util.EventListener", myRefExpr.getResolveScope());
myPropertyNames.addAll(myPreferredFieldNames);
myFieldPointerOperator = myRefExpr.hasAt();
myMethodPointerOperator = myRefExpr.getDotTokenType() == GroovyTokenTypes.mMEMBER_POINTER;
myIsMap = isMap();
final PsiType thisType = GrReferenceResolveUtil.getQualifierType(myRefExpr);
mySubstitutorComputer =
new SubstitutorComputer(
thisType, PsiType.EMPTY_ARRAY, PsiType.EMPTY_ARRAY, myRefExpr, myRefExpr.getParent());
}
private static PsiSubstitutor obtainFinalSubstitutor(
PsiClass superClass,
PsiSubstitutor superSubstitutor,
PsiSubstitutor derivedSubstitutor,
boolean inRawContext) {
if (inRawContext) {
Set<PsiTypeParameter> typeParams = superSubstitutor.getSubstitutionMap().keySet();
PsiElementFactory factory = JavaPsiFacade.getElementFactory(superClass.getProject());
superSubstitutor =
factory.createRawSubstitutor(
derivedSubstitutor, typeParams.toArray(new PsiTypeParameter[typeParams.size()]));
}
Map<PsiTypeParameter, PsiType> map = null;
for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(superClass)) {
PsiType type = superSubstitutor.substitute(typeParameter);
final PsiType t = derivedSubstitutor.substitute(type);
if (map == null) {
map = new THashMap<PsiTypeParameter, PsiType>();
}
map.put(typeParameter, t);
}
return map == null
? PsiSubstitutor.EMPTY
: JavaPsiFacade.getInstance(superClass.getProject())
.getElementFactory()
.createSubstitutor(map);
}
public void updateThrowsList(PsiClassType exceptionType) {
if (!getSuperMethods().isEmpty()) {
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).updateThrowsList(exceptionType);
}
} else if (myUnThrownExceptions != null) {
if (exceptionType == null) {
myUnThrownExceptions = null;
return;
}
PsiClass exceptionClass = exceptionType.resolve();
JavaPsiFacade facade = JavaPsiFacade.getInstance(myManager.getProject());
for (int i = myUnThrownExceptions.size() - 1; i >= 0; i--) {
String exceptionFqn = myUnThrownExceptions.get(i);
PsiClass classType =
facade.findClass(
exceptionFqn, GlobalSearchScope.allScope(getRefManager().getProject()));
if (InheritanceUtil.isInheritorOrSelf(exceptionClass, classType, true)
|| InheritanceUtil.isInheritorOrSelf(classType, exceptionClass, true)) {
myUnThrownExceptions.remove(i);
}
}
if (myUnThrownExceptions.isEmpty()) myUnThrownExceptions = null;
}
}
@NotNull
public Object[] getVariants() {
PsiElement context = getContext();
if (context == null) {
context = JavaPsiFacade.getInstance(getElement().getProject()).findPackage("");
}
if (context instanceof PsiPackage) {
final String[] extendClasses = getExtendClassNames();
if (extendClasses != null) {
return getSubclassVariants((PsiPackage) context, extendClasses);
}
return processPackage((PsiPackage) context);
}
if (context instanceof PsiClass) {
final PsiClass aClass = (PsiClass) context;
if (myInStaticImport) {
return ArrayUtil.mergeArrays(aClass.getInnerClasses(), aClass.getFields(), Object.class);
} else if (isDefinitelyStatic()) {
final PsiClass[] psiClasses = aClass.getInnerClasses();
final List<PsiClass> staticClasses = new ArrayList<PsiClass>(psiClasses.length);
for (PsiClass c : psiClasses) {
if (c.hasModifierProperty(PsiModifier.STATIC)) {
staticClasses.add(c);
}
}
return staticClasses.isEmpty()
? PsiClass.EMPTY_ARRAY
: staticClasses.toArray(new PsiClass[staticClasses.size()]);
}
}
return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
@Nullable
private LocalQuickFix[] createNPEFixes(
PsiExpression qualifier, PsiExpression expression, boolean onTheFly) {
if (qualifier == null || expression == null) return null;
if (qualifier instanceof PsiMethodCallExpression) return null;
if (qualifier instanceof PsiLiteralExpression
&& ((PsiLiteralExpression) qualifier).getValue() == null) return null;
try {
final List<LocalQuickFix> fixes = new SmartList<LocalQuickFix>();
if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4)) {
final Project project = qualifier.getProject();
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(project).getElementFactory();
final PsiBinaryExpression binary =
(PsiBinaryExpression) elementFactory.createExpressionFromText("a != null", null);
binary.getLOperand().replace(qualifier);
fixes.add(new AddAssertStatementFix(binary));
}
addSurroundWithIfFix(qualifier, fixes, onTheFly);
if (ReplaceWithTernaryOperatorFix.isAvailable(qualifier, expression)) {
fixes.add(new ReplaceWithTernaryOperatorFix(qualifier));
}
return fixes.toArray(new LocalQuickFix[fixes.size()]);
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static boolean canBePrivate(
PsiMethod method,
Collection<PsiReference> references,
Collection<? extends PsiElement> deleted,
final PsiElement[] allElementsToDelete) {
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
return false;
}
PsiManager manager = method.getManager();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
final PsiElementFactory factory = facade.getElementFactory();
final PsiModifierList privateModifierList;
try {
final PsiMethod newMethod = factory.createMethod("x3", PsiType.VOID);
privateModifierList = newMethod.getModifierList();
privateModifierList.setModifierProperty(PsiModifier.PRIVATE, true);
} catch (IncorrectOperationException e) {
LOG.assertTrue(false);
return false;
}
for (PsiReference reference : references) {
final PsiElement element = reference.getElement();
if (!isInside(element, allElementsToDelete)
&& !isInside(element, deleted)
&& !facade
.getResolveHelper()
.isAccessible(method, privateModifierList, element, null, null)) {
return false;
}
}
return true;
}
public static PsiType eliminateWildcards(PsiType type, final boolean eliminateInTypeArguments) {
if (eliminateInTypeArguments && type instanceof PsiClassType) {
PsiClassType classType = (PsiClassType) type;
JavaResolveResult resolveResult = classType.resolveGenerics();
PsiClass aClass = (PsiClass) resolveResult.getElement();
if (aClass != null) {
PsiManager manager = aClass.getManager();
PsiTypeParameter[] typeParams = aClass.getTypeParameters();
Map<PsiTypeParameter, PsiType> map = new HashMap<PsiTypeParameter, PsiType>();
for (PsiTypeParameter typeParam : typeParams) {
PsiType substituted = resolveResult.getSubstitutor().substitute(typeParam);
if (substituted instanceof PsiWildcardType) {
substituted = ((PsiWildcardType) substituted).getBound();
if (substituted == null)
substituted = TypeConversionUtil.typeParameterErasure(typeParam);
}
map.put(typeParam, substituted);
}
PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
PsiSubstitutor substitutor = factory.createSubstitutor(map);
type = factory.createType(aClass, substitutor);
}
} else if (type instanceof PsiArrayType) {
return eliminateWildcards(((PsiArrayType) type).getComponentType(), false).createArrayType();
} else if (type instanceof PsiWildcardType) {
final PsiType bound = ((PsiWildcardType) type).getBound();
return bound != null ? bound : ((PsiWildcardType) type).getExtendsBound(); // object
} else if (type instanceof PsiCapturedWildcardType && !eliminateInTypeArguments) {
return eliminateWildcards(
((PsiCapturedWildcardType) type).getWildcard(), eliminateInTypeArguments);
}
return type;
}
@Nullable
public PsiClass getPsiElement() {
final String qualifiedName = data.getMainClassName();
return qualifiedName != null
? JavaPsiFacade.getInstance(getProject())
.findClass(qualifiedName, GlobalSearchScope.allScope(project))
: null;
}
private List<PsiClass> calculateInterfacesSupported() {
final List<PsiClass> out = new ArrayList<PsiClass>();
final PsiClass[] supers = sourceClass.getSupers();
for (PsiClass superClass : supers) {
if (!superClass.isInterface()) {
continue;
}
final PsiMethod[] superclassMethods = superClass.getMethods();
if (superclassMethods.length == 0) {
continue;
}
boolean allMethodsCovered = true;
for (PsiMethod method : superclassMethods) {
boolean isCovered = false;
for (PsiMethod movedMethod : methods) {
if (isSuperMethod(method, movedMethod)) {
isCovered = true;
break;
}
}
if (!isCovered) {
allMethodsCovered = false;
break;
}
}
if (allMethodsCovered) {
out.add(superClass);
}
}
final Project project = sourceClass.getProject();
final PsiManager manager = sourceClass.getManager();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
if (usesDefaultSerialization(sourceClass)) {
final PsiClass serializable =
JavaPsiFacade.getInstance(manager.getProject()).findClass("java.io.Serializable", scope);
out.add(serializable);
}
if (usesDefaultClone(sourceClass)) {
final PsiClass cloneable =
JavaPsiFacade.getInstance(manager.getProject()).findClass("java.lang.Cloneable", scope);
out.add(cloneable);
}
return out;
}
@Override
public PsiType substitute(@NotNull PsiTypeParameter typeParameter) {
if (containsInMap(typeParameter)) {
return getFromMap(typeParameter);
}
return JavaPsiFacade.getInstance(typeParameter.getProject())
.getElementFactory()
.createType(typeParameter);
}
private static PsiType createType(PsiClass cls, PsiSubstitutor currentSubstitutor, int arrayDim) {
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(cls.getProject()).getElementFactory();
PsiType newType = elementFactory.createType(cls, currentSubstitutor);
for (int i = 0; i < arrayDim; i++) {
newType = newType.createArrayType();
}
return newType;
}
private static PsiParameter createNewParameter(
JavaChangeInfo changeInfo, JavaParameterInfo newParm, PsiSubstitutor substitutor)
throws IncorrectOperationException {
final PsiParameterList list = changeInfo.getMethod().getParameterList();
final PsiElementFactory factory =
JavaPsiFacade.getInstance(list.getProject()).getElementFactory();
final PsiType type = substitutor.substitute(newParm.createType(list, list.getManager()));
return factory.createParameter(newParm.getName(), type);
}
private static boolean changeClassTypeArgument(
PsiMethod myMethod,
Project project,
PsiType superReturnType,
PsiClass superClass,
Editor editor,
PsiType returnType) {
if (superClass == null || !superClass.hasTypeParameters()) return true;
final PsiClass superReturnTypeClass = PsiUtil.resolveClassInType(superReturnType);
if (superReturnTypeClass == null
|| !(superReturnTypeClass instanceof PsiTypeParameter
|| superReturnTypeClass.hasTypeParameters())) return true;
final PsiClass derivedClass = myMethod.getContainingClass();
if (derivedClass == null) return true;
final PsiReferenceParameterList referenceParameterList =
findTypeArgumentsList(superClass, derivedClass);
if (referenceParameterList == null) return true;
final PsiElement resolve =
((PsiJavaCodeReferenceElement) referenceParameterList.getParent()).resolve();
if (!(resolve instanceof PsiClass)) return true;
final PsiClass baseClass = (PsiClass) resolve;
if (returnType instanceof PsiPrimitiveType) {
returnType = ((PsiPrimitiveType) returnType).getBoxedType(derivedClass);
}
final PsiSubstitutor superClassSubstitutor =
TypeConversionUtil.getSuperClassSubstitutor(superClass, baseClass, PsiSubstitutor.EMPTY);
final PsiType superReturnTypeInBaseClassType =
superClassSubstitutor.substitute(superReturnType);
final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(project).getResolveHelper();
final PsiSubstitutor psiSubstitutor =
resolveHelper.inferTypeArguments(
PsiTypesUtil.filterUnusedTypeParameters(
superReturnTypeInBaseClassType, baseClass.getTypeParameters()),
new PsiType[] {superReturnTypeInBaseClassType},
new PsiType[] {returnType},
PsiUtil.getLanguageLevel(superClass));
final TypeMigrationRules rules = new TypeMigrationRules();
final PsiSubstitutor compoundSubstitutor =
TypeConversionUtil.getSuperClassSubstitutor(superClass, derivedClass, PsiSubstitutor.EMPTY)
.putAll(psiSubstitutor);
rules.setBoundScope(new LocalSearchScope(derivedClass));
TypeMigrationProcessor.runHighlightingTypeMigration(
project,
editor,
rules,
referenceParameterList,
JavaPsiFacade.getElementFactory(project).createType(baseClass, compoundSubstitutor));
return false;
}
private static PsiExpression createThisExpr(final PsiManager manager) {
try {
return JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createExpressionFromText("this", null);
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private boolean isAccessible(final PsiElement element) {
if (!myCheckAccess) return true;
if (!(element instanceof PsiMember)) return true;
PsiMember member = (PsiMember) element;
return JavaPsiFacade.getInstance(element.getProject())
.getResolveHelper()
.isAccessible(
member, member.getModifierList(), myElement, myQualifierClass, myDeclarationHolder);
}
public static PsiMethod generateSetterPrototype(
PsiField field, final PsiClass containingClass, boolean returnSelf) {
Project project = field.getProject();
JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory();
String name = field.getName();
boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
VariableKind kind = codeStyleManager.getVariableKind(field);
String propertyName = codeStyleManager.variableNameToPropertyName(name, kind);
String setName = suggestSetterName(project, field);
try {
PsiMethod setMethod =
factory.createMethod(
setName, returnSelf ? factory.createType(containingClass) : PsiType.VOID);
String parameterName =
codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
PsiParameter param = factory.createParameter(parameterName, field.getType());
annotateWithNullableStuff(field, factory, param);
setMethod.getParameterList().add(param);
PsiUtil.setModifierProperty(setMethod, PsiModifier.PUBLIC, true);
PsiUtil.setModifierProperty(setMethod, PsiModifier.STATIC, isStatic);
@NonNls StringBuffer buffer = new StringBuffer();
buffer.append("{\n");
if (name.equals(parameterName)) {
if (!isStatic) {
buffer.append("this.");
} else {
String className = containingClass.getName();
if (className != null) {
buffer.append(className);
buffer.append(".");
}
}
}
buffer.append(name);
buffer.append("=");
buffer.append(parameterName);
buffer.append(";\n");
if (returnSelf) {
buffer.append("return this;\n");
}
buffer.append("}");
PsiCodeBlock body = factory.createCodeBlockFromText(buffer.toString(), null);
setMethod.getBody().replace(body);
setMethod = (PsiMethod) CodeStyleManager.getInstance(project).reformat(setMethod);
return setMethod;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}