private static String getName(
final PsiClass psiClass, final LookupItem<?> item, boolean diamond) {
if (item instanceof JavaPsiClassReferenceElement) {
String forced = ((JavaPsiClassReferenceElement) item).getForcedPresentableName();
if (forced != null) {
return forced;
}
}
String name = PsiUtilCore.getName(psiClass);
if (item.getAttribute(LookupItem.FORCE_QUALIFY) != null) {
if (psiClass.getContainingClass() != null) {
name = psiClass.getContainingClass().getName() + "." + name;
}
}
if (diamond) {
return name + "<>";
}
PsiSubstitutor substitutor = (PsiSubstitutor) item.getAttribute(LookupItem.SUBSTITUTOR);
if (substitutor != null) {
final PsiTypeParameter[] params = psiClass.getTypeParameters();
if (params.length > 0) {
return name + formatTypeParameters(substitutor, params);
}
}
return StringUtil.notNullize(name);
}
@Nullable
private String verifyInnerClassDestination() {
PsiClass targetClass = findTargetClass();
if (targetClass == null) return null;
for (PsiElement element : myElementsToMove) {
if (PsiTreeUtil.isAncestor(element, targetClass, false)) {
return RefactoringBundle.message("move.class.to.inner.move.to.self.error");
}
final Language targetClassLanguage = targetClass.getLanguage();
if (!element.getLanguage().equals(targetClassLanguage)) {
return RefactoringBundle.message(
"move.to.different.language",
UsageViewUtil.getType(element),
((PsiClass) element).getQualifiedName(),
targetClass.getQualifiedName());
}
if (element.getLanguage().equals(Language.findLanguageByID("Groovy"))) {
return RefactoringBundle.message("dont.support.inner.classes", "Groovy");
}
}
while (targetClass != null) {
if (targetClass.getContainingClass() != null
&& !targetClass.hasModifierProperty(PsiModifier.STATIC)) {
return RefactoringBundle.message("move.class.to.inner.nonstatic.error");
}
targetClass = targetClass.getContainingClass();
}
return null;
}
private static String createText(PsiClass aClass) {
String text = aClass.getName();
PsiClass containingClass = aClass.getContainingClass();
while (containingClass != null) {
text = containingClass.getName() + '.' + text;
containingClass = containingClass.getContainingClass();
}
return text;
}
@Nullable
private static String getTopmostOwnerClassQualifiedName(@NotNull PsiClass psiClass) {
PsiClass ownerClass = null;
for (PsiClass aClass = psiClass.getContainingClass();
aClass != null;
aClass = aClass.getContainingClass()) {
ownerClass = aClass;
}
if (ownerClass != null) {
return ownerClass.getQualifiedName();
}
return null;
}
private Domination dominates(
PsiClass aClass, boolean accessible, String fqName, ClassCandidateInfo info) {
final PsiClass otherClass = info.getElement();
assert otherClass != null;
String otherQName = otherClass.getQualifiedName();
if (fqName.equals(otherQName)) {
return Domination.DOMINATED_BY;
}
final PsiClass containingClass1 = aClass.getContainingClass();
final PsiClass containingClass2 = otherClass.getContainingClass();
if (containingClass1 != null
&& containingClass2 != null
&& containingClass2.isInheritor(containingClass1, true)
&& !isImported(myCurrentFileContext)) {
// shadowing
return Domination.DOMINATED_BY;
}
boolean infoAccessible = info.isAccessible();
if (infoAccessible && !accessible) {
return Domination.DOMINATED_BY;
}
if (!infoAccessible && accessible) {
return Domination.DOMINATES;
}
// everything wins over class from default package
boolean isDefault = StringUtil.getPackageName(fqName).length() == 0;
boolean otherDefault =
otherQName != null && StringUtil.getPackageName(otherQName).length() == 0;
if (isDefault && !otherDefault) {
return Domination.DOMINATED_BY;
}
if (!isDefault && otherDefault) {
return Domination.DOMINATES;
}
// single import wins over on-demand
boolean myOnDemand = isOnDemand(myCurrentFileContext, aClass);
boolean otherOnDemand = isOnDemand(info.getCurrentFileResolveScope(), otherClass);
if (myOnDemand && !otherOnDemand) {
return Domination.DOMINATED_BY;
}
if (!myOnDemand && otherOnDemand) {
return Domination.DOMINATES;
}
return Domination.EQUAL;
}
@Override
public void visitAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) {
if (anonymousClass instanceof PsiEnumConstantInitializer) {
return;
}
final PsiMember containingMember =
PsiTreeUtil.getParentOfType(anonymousClass, PsiMember.class);
if (containingMember == null || containingMember.hasModifierProperty(PsiModifier.STATIC)) {
return;
}
final PsiJavaCodeReferenceElement reference = anonymousClass.getBaseClassReference();
if (reference.resolve() == null) {
// don't warn on broken code
return;
}
final PsiClass containingClass = PsiTreeUtil.getParentOfType(anonymousClass, PsiClass.class);
if (containingClass == null) {
return;
}
if (containingClass.getContainingClass() != null
&& !containingClass.hasModifierProperty(PsiModifier.STATIC)) {
// strictly speaking can be named static inner class but not when part of the current
// containing class
return;
}
final InnerClassReferenceVisitor visitor = new InnerClassReferenceVisitor(anonymousClass);
anonymousClass.accept(visitor);
if (!visitor.canInnerClassBeStatic()) {
return;
}
if (hasReferenceToLocalClass(anonymousClass)) {
return;
}
registerClassError(anonymousClass);
}
@SuppressWarnings({"HardCodedStringLiteral"})
private static JVMName getJVMSignature(
@Nullable PsiMethod method, boolean constructor, @Nullable PsiClass declaringClass) {
JVMNameBuffer signature = new JVMNameBuffer();
signature.append("(");
if (constructor) {
if (declaringClass != null) {
final PsiClass outerClass = declaringClass.getContainingClass();
if (outerClass != null) {
// declaring class is an inner class
if (!declaringClass.hasModifierProperty(PsiModifier.STATIC)) {
appendJvmClassQualifiedName(signature, getJVMQualifiedName(outerClass));
}
}
}
}
if (method != null) {
for (PsiParameter psiParameter : method.getParameterList().getParameters()) {
appendJVMSignature(signature, psiParameter.getType());
}
}
signature.append(")");
if (!constructor && method != null) {
appendJVMSignature(signature, method.getReturnType());
} else {
signature.append(new JVMRawText("V"));
}
return signature.toName();
}
@Nullable
public static PsiQualifiedReference getClassReferenceToShorten(
@NotNull final PsiClass refClass,
final boolean addImports,
@NotNull final PsiQualifiedReference reference) {
PsiClass parentClass = refClass.getContainingClass();
if (parentClass != null) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(parentClass.getProject());
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
if (resolveHelper.isAccessible(refClass, reference, null)
&& isSafeToShortenReference(reference.getReferenceName(), reference, refClass)) {
return reference;
}
if (!CodeStyleSettingsManager.getSettings(reference.getProject())
.INSERT_INNER_CLASS_IMPORTS) {
final PsiElement qualifier = reference.getQualifier();
if (qualifier instanceof PsiQualifiedReference) {
return getClassReferenceToShorten(
parentClass, addImports, (PsiQualifiedReference) qualifier);
}
return null;
}
}
if (addImports && !((PsiImportHolder) reference.getContainingFile()).importClass(refClass))
return null;
if (!isSafeToShortenReference(reference, refClass)) return null;
return reference;
}
@NotNull
private PsiSubstitutor mapSubstitutor(
PsiClass originalClass, PsiClass mappedClass, PsiSubstitutor substitutor) {
PsiTypeParameter[] typeParameters = mappedClass.getTypeParameters();
PsiTypeParameter[] originalTypeParameters = originalClass.getTypeParameters();
if (typeParameters.length != originalTypeParameters.length) {
if (originalTypeParameters.length == 0) {
return JavaPsiFacade.getElementFactory(mappedClass.getProject())
.createRawSubstitutor(mappedClass);
}
return substitutor;
}
Map<PsiTypeParameter, PsiType> substitutionMap = substitutor.getSubstitutionMap();
PsiSubstitutor mappedSubstitutor = PsiSubstitutor.EMPTY;
for (int i = 0; i < originalTypeParameters.length; i++) {
if (!substitutionMap.containsKey(originalTypeParameters[i])) continue;
PsiType originalSubstitute = substitutor.substitute(originalTypeParameters[i]);
if (originalSubstitute != null) {
PsiType substitute = mapType(originalSubstitute);
if (substitute == null) return substitutor;
mappedSubstitutor = mappedSubstitutor.put(typeParameters[i], substitute);
} else {
mappedSubstitutor = mappedSubstitutor.put(typeParameters[i], null);
}
}
if (mappedClass.hasModifierProperty(PsiModifier.STATIC)) {
return mappedSubstitutor;
}
PsiClass mappedContaining = mappedClass.getContainingClass();
PsiClass originalContaining = originalClass.getContainingClass();
//noinspection DoubleNegation
if ((mappedContaining != null) != (originalContaining != null)) {
return substitutor;
}
if (mappedContaining != null) {
return mappedSubstitutor.putAll(
mapSubstitutor(originalContaining, mappedContaining, substitutor));
}
return mappedSubstitutor;
}
private boolean checkAccessibility(final PsiClass aClass) {
// We don't care about accessibility in javadoc
if (JavaResolveUtil.isInJavaDoc(myPlace)) {
return true;
}
if (PsiImplUtil.isInServerPage(aClass.getContainingFile())) {
PsiFile file = FileContextUtil.getContextFile(myPlace);
if (PsiImplUtil.isInServerPage(file)) {
return true;
}
}
boolean accessible = true;
if (aClass instanceof PsiTypeParameter) {
accessible = !myStaticContext;
}
PsiManager manager = aClass.getManager();
if (aClass.hasModifierProperty(PsiModifier.PRIVATE)) {
PsiElement parent = aClass.getParent();
while (true) {
PsiElement parentScope = parent.getParent();
if (parentScope instanceof PsiJavaFile) break;
parent = parentScope;
if (!(parentScope instanceof PsiClass)) break;
}
if (parent instanceof PsiDeclarationStatement) {
parent = parent.getParent();
}
accessible = false;
for (PsiElement placeParent = myPlace;
placeParent != null;
placeParent = placeParent.getContext()) {
if (manager.areElementsEquivalent(placeParent, parent)) accessible = true;
}
}
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
if (aClass.hasModifierProperty(PsiModifier.PROTECTED)) {
accessible = false;
if (myPlace != null && facade.arePackagesTheSame(aClass, myPlace)) {
accessible = true;
} else {
if (aClass.getContainingClass() != null) {
accessible =
myAccessClass == null
|| myPlace != null
&& facade.getResolveHelper().isAccessible(aClass, myPlace, myAccessClass);
}
}
}
if (aClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) {
if (myPlace == null || !facade.arePackagesTheSame(aClass, myPlace)) {
accessible = false;
}
}
return accessible;
}
private static PsiTypeLookupItem doCreateItem(
final PsiType type,
PsiElement context,
int bracketsCount,
boolean diamond,
InsertHandler<PsiTypeLookupItem> importFixer) {
if (type instanceof PsiClassType) {
PsiClassType.ClassResolveResult classResolveResult = ((PsiClassType) type).resolveGenerics();
final PsiClass psiClass = classResolveResult.getElement();
if (psiClass != null) {
String name = psiClass.getName();
if (name != null) {
final PsiSubstitutor substitutor = classResolveResult.getSubstitutor();
PsiClass resolved =
JavaPsiFacade.getInstance(psiClass.getProject())
.getResolveHelper()
.resolveReferencedClass(name, context);
Set<String> allStrings = new HashSet<String>();
allStrings.add(name);
if (!psiClass.getManager().areElementsEquivalent(resolved, psiClass)
&& !PsiUtil.isInnerClass(psiClass)) {
// inner class name should be shown qualified if its not accessible by single name
PsiClass aClass = psiClass.getContainingClass();
while (aClass != null && !PsiUtil.isInnerClass(aClass) && aClass.getName() != null) {
name = aClass.getName() + '.' + name;
allStrings.add(name);
aClass = aClass.getContainingClass();
}
}
PsiTypeLookupItem item =
new PsiTypeLookupItem(
psiClass, name, diamond, bracketsCount, importFixer, substitutor);
item.addLookupStrings(ArrayUtil.toStringArray(allStrings));
return item;
}
}
}
return new PsiTypeLookupItem(
type, type.getPresentableText(), false, bracketsCount, importFixer, PsiSubstitutor.EMPTY);
}
private boolean isAmbiguousInherited(PsiClass containingClass1) {
PsiClass psiClass = PsiTreeUtil.getParentOfType(myPlace, PsiClass.class);
while (psiClass != null) {
if (psiClass.isInheritor(containingClass1, false)) {
return true;
}
psiClass = psiClass.getContainingClass();
}
return false;
}
private boolean isAccessible(PsiClass otherClass) {
if (otherClass.hasModifierProperty(PsiModifier.PRIVATE)) {
final PsiClass containingClass = otherClass.getContainingClass();
PsiClass containingPlaceClass = PsiTreeUtil.getParentOfType(myPlace, PsiClass.class, false);
while (containingPlaceClass != null) {
if (containingClass == containingPlaceClass) {
return true;
}
containingPlaceClass = PsiTreeUtil.getParentOfType(containingPlaceClass, PsiClass.class);
}
return false;
}
return true;
}
@Nullable
private static String getDescriptionDirName(PsiClass aClass) {
String descriptionDir = "";
PsiClass each = aClass;
while (each != null) {
String name = each.getName();
if (StringUtil.isEmptyOrSpaces(name)) {
return null;
}
descriptionDir = name + descriptionDir;
each = each.getContainingClass();
}
return descriptionDir;
}
private static boolean isRunnable(final PsiClass psiClass) {
if (!(psiClass instanceof GrTypeDefinition)) return false;
if (psiClass instanceof PsiAnonymousClass) return false;
if (psiClass.isInterface()) return false;
final PsiClass runnable =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass("java.lang.Runnable", psiClass.getResolveScope());
if (runnable == null) return false;
final PsiMethod runMethod = runnable.getMethods()[0];
final PsiMethod[] runImplementations = psiClass.findMethodsBySignature(runMethod, false);
if (runImplementations.length == 1
&& runImplementations[0] instanceof GrMethod
&& ((GrMethod) runImplementations[0]).getBlock() != null) {
return psiClass.getContainingClass() == null
|| psiClass.hasModifierProperty(PsiModifier.STATIC);
}
return false;
}
private boolean processClass(
PsiClass resolve,
PsiSubstitutor originalSubstitutor,
final Map<PsiTypeParameter, PsiType> substMap) {
final PsiTypeParameter[] params = resolve.getTypeParameters();
for (final PsiTypeParameter param : params) {
final PsiType original = originalSubstitutor.substitute(param);
if (original == null) {
substMap.put(param, null);
} else {
substMap.put(param, substituteInternal(original));
}
}
if (resolve.hasModifierProperty(PsiModifier.STATIC)) return true;
final PsiClass containingClass = resolve.getContainingClass();
return containingClass == null
|| processClass(containingClass, originalSubstitutor, substMap);
}
static Collection<PsiClass> getCompiledClassesForTopLevelObjects(
Project project, GlobalSearchScope scope) {
Set<PsiClass> jetObjectClasses = Sets.newHashSet();
Collection<PsiClass> classesByAnnotation =
getClassesByAnnotation(KotlinClass.class.getSimpleName(), project, scope);
for (PsiClass psiClass : classesByAnnotation) {
ClassKind kind = getCompiledClassKind(psiClass);
if (kind == null) {
continue;
}
if (psiClass.getContainingClass() == null && kind == ClassKind.OBJECT) {
jetObjectClasses.add(psiClass);
}
}
return jetObjectClasses;
}
public static void addImportIfNeeded(@NotNull PsiClass aClass, @NotNull PsiElement context) {
final PsiFile file = context.getContainingFile();
if (!(file instanceof PsiJavaFile)) {
return;
}
final PsiJavaFile javaFile = (PsiJavaFile) file;
final PsiClass outerClass = aClass.getContainingClass();
if (outerClass == null) {
if (PsiTreeUtil.isAncestor(javaFile, aClass, true)) {
return;
}
} else if (PsiTreeUtil.isAncestor(outerClass, context, true)) {
final PsiElement brace = outerClass.getLBrace();
if (brace != null && brace.getTextOffset() < context.getTextOffset()) {
return;
}
}
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null) {
return;
}
final PsiImportList importList = javaFile.getImportList();
if (importList == null) {
return;
}
final String containingPackageName = javaFile.getPackageName();
@NonNls final String packageName = ClassUtil.extractPackageName(qualifiedName);
if (containingPackageName.equals(packageName)
|| importList.findSingleClassImportStatement(qualifiedName) != null) {
return;
}
if (importList.findOnDemandImportStatement(packageName) != null
&& !hasDefaultImportConflict(qualifiedName, javaFile)
&& !hasOnDemandImportConflict(qualifiedName, javaFile)) {
return;
}
final Project project = importList.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiElementFactory elementFactory = psiFacade.getElementFactory();
final PsiImportStatement importStatement = elementFactory.createImportStatement(aClass);
importList.add(importStatement);
}
@NotNull
public static SearchScope getClassUseScope(@NotNull PsiClass aClass) {
if (aClass instanceof PsiAnonymousClass) {
return new LocalSearchScope(aClass);
}
final GlobalSearchScope maximalUseScope = ResolveScopeManager.getElementUseScope(aClass);
PsiFile file = aClass.getContainingFile();
if (PsiImplUtil.isInServerPage(file)) return maximalUseScope;
final PsiClass containingClass = aClass.getContainingClass();
if (aClass.hasModifierProperty(PsiModifier.PUBLIC)
|| aClass.hasModifierProperty(PsiModifier.PROTECTED)) {
return containingClass == null ? maximalUseScope : containingClass.getUseScope();
} else if (aClass.hasModifierProperty(PsiModifier.PRIVATE)
|| aClass instanceof PsiTypeParameter) {
PsiClass topClass = PsiUtil.getTopLevelClass(aClass);
return new LocalSearchScope(topClass == null ? aClass.getContainingFile() : topClass);
} else {
PsiPackage aPackage = null;
if (file instanceof PsiJavaFile) {
aPackage =
JavaPsiFacade.getInstance(aClass.getProject())
.findPackage(((PsiJavaFile) file).getPackageName());
}
if (aPackage == null) {
PsiDirectory dir = file.getContainingDirectory();
if (dir != null) {
aPackage = JavaDirectoryService.getInstance().getPackage(dir);
}
}
if (aPackage != null) {
SearchScope scope = PackageScope.packageScope(aPackage, false);
scope = scope.intersectWith(maximalUseScope);
return scope;
}
return new LocalSearchScope(file);
}
}
private static boolean isSafeToShortenReference(
final String referenceText, final PsiElement psiReference, final PsiClass refClass) {
final PsiManager manager = refClass.getManager();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
final PsiResolveHelper helper = facade.getResolveHelper();
if (manager.areElementsEquivalent(
refClass, helper.resolveReferencedClass(referenceText, psiReference))) {
if (psiReference instanceof PsiJavaCodeReferenceElement) {
PsiElement parent = psiReference.getParent();
if (parent instanceof PsiNewExpression || parent.getParent() instanceof PsiNewExpression)
return true;
if (parent instanceof PsiTypeElement
&& parent.getParent() instanceof PsiInstanceOfExpression) {
final PsiClass containingClass = refClass.getContainingClass();
if (containingClass != null && containingClass.hasTypeParameters()) {
return false;
}
}
}
return helper.resolveReferencedVariable(referenceText, psiReference) == null;
}
return false;
}
private static LookupItem doCreateItem(PsiType type, PsiElement context) {
if (type instanceof PsiClassType) {
PsiClassType.ClassResolveResult classResolveResult = ((PsiClassType) type).resolveGenerics();
final PsiClass psiClass = classResolveResult.getElement();
final PsiSubstitutor substitutor = classResolveResult.getSubstitutor();
final String text = type.getCanonicalText();
String typeString = text;
String typeParams = "";
if (text.indexOf('<') > 0 && text.endsWith(">")) {
typeString = text.substring(0, text.indexOf('<'));
typeParams = text.substring(text.indexOf('<'));
}
String lookupString = text.substring(typeString.lastIndexOf('.') + 1);
if (psiClass != null) {
PsiClass resolved =
JavaPsiFacade.getInstance(psiClass.getProject())
.getResolveHelper()
.resolveReferencedClass(psiClass.getName(), context);
if (!psiClass.getManager().areElementsEquivalent(resolved, psiClass)) {
// inner class name should be shown qualified if its not accessible by single name
PsiClass aClass = psiClass;
lookupString = "";
while (aClass != null) {
lookupString = aClass.getName() + (lookupString == "" ? "" : ".") + lookupString;
aClass = aClass.getContainingClass();
}
lookupString += typeParams;
}
LookupItem item = new PsiTypeLookupItem(psiClass, lookupString);
item.setAttribute(SUBSTITUTOR, substitutor);
return item;
}
}
return new LookupItem(type, type.getPresentableText());
}
private Domination dominates(
PsiClass aClass, boolean accessible, String fqName, ClassCandidateInfo info) {
final PsiClass otherClass = info.getElement();
assert otherClass != null;
String otherQName = otherClass.getQualifiedName();
if (fqName.equals(otherQName)) {
return Domination.DOMINATED_BY;
}
final PsiClass containingClass1 = aClass.getContainingClass();
final PsiClass containingClass2 = otherClass.getContainingClass();
if (myAccessClass != null && !Comparing.equal(containingClass1, containingClass2)) {
if (myAccessClass.equals(containingClass1)) return Domination.DOMINATES;
if (myAccessClass.equals(containingClass2)) return Domination.DOMINATED_BY;
}
// JLS 8.5:
// A class may inherit two or more type declarations with the same name, either from two
// interfaces or from its superclass and an interface.
// It is a compile-time error to attempt to refer to any ambiguously inherited class or
// interface by its simple name.
if (containingClass1 != null
&& containingClass2 != null
&& containingClass2.isInheritor(containingClass1, true)
&& !isImported(myCurrentFileContext)) {
if (!isAmbiguousInherited(containingClass1)) {
// shadowing
return Domination.DOMINATED_BY;
}
}
boolean infoAccessible = info.isAccessible() && isAccessible(otherClass);
if (infoAccessible && !accessible) {
return Domination.DOMINATED_BY;
}
if (!infoAccessible && accessible) {
return Domination.DOMINATES;
}
// everything wins over class from default package
boolean isDefault = StringUtil.getPackageName(fqName).length() == 0;
boolean otherDefault =
otherQName != null && StringUtil.getPackageName(otherQName).length() == 0;
if (isDefault && !otherDefault) {
return Domination.DOMINATED_BY;
}
if (!isDefault && otherDefault) {
return Domination.DOMINATES;
}
// single import wins over on-demand
boolean myOnDemand = isOnDemand(myCurrentFileContext, aClass);
boolean otherOnDemand = isOnDemand(info.getCurrentFileResolveScope(), otherClass);
if (myOnDemand && !otherOnDemand) {
return Domination.DOMINATED_BY;
}
if (!myOnDemand && otherOnDemand) {
return Domination.DOMINATES;
}
return Domination.EQUAL;
}
@Override
public ASTNode process(
@NotNull ASTNode element,
boolean addImports,
boolean incompleteCode,
boolean useFqInJavadoc,
boolean useFqInCode) {
IElementType elementType = element.getElementType();
if ((elementType == JavaElementType.JAVA_CODE_REFERENCE
|| elementType == JavaElementType.REFERENCE_EXPRESSION)
&& !isAnnotated(element)) {
IElementType parentType = element.getTreeParent().getElementType();
if (elementType == JavaElementType.JAVA_CODE_REFERENCE
|| incompleteCode
|| parentType == JavaElementType.REFERENCE_EXPRESSION
|| parentType == JavaElementType.METHOD_REF_EXPRESSION) {
PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement) element.getPsi();
PsiReferenceParameterList parameterList = ref.getParameterList();
if (parameterList != null) {
PsiTypeElement[] typeParameters = parameterList.getTypeParameterElements();
for (PsiTypeElement typeParameter : typeParameters) {
process(
typeParameter.getNode(), addImports, incompleteCode, useFqInJavadoc, useFqInCode);
}
}
boolean rightKind = true;
if (elementType == JavaElementType.JAVA_CODE_REFERENCE) {
PsiJavaCodeReferenceElementImpl impl = (PsiJavaCodeReferenceElementImpl) element;
int kind = impl.getKind(impl.getContainingFile());
rightKind =
kind == PsiJavaCodeReferenceElementImpl.CLASS_NAME_KIND
|| kind == PsiJavaCodeReferenceElementImpl.CLASS_OR_PACKAGE_NAME_KIND;
}
if (rightKind) {
// annotations may jump out of reference (see PsiJavaCodeReferenceImpl#setAnnotations())
// so they should be processed first
List<PsiAnnotation> annotations =
PsiTreeUtil.getChildrenOfTypeAsList(ref, PsiAnnotation.class);
for (PsiAnnotation annotation : annotations) {
process(annotation.getNode(), addImports, incompleteCode, useFqInJavadoc, useFqInCode);
}
boolean isInsideDocComment =
TreeUtil.findParent(element, JavaDocElementType.DOC_COMMENT) != null;
boolean isShort = !ref.isQualified();
if (isInsideDocComment ? !useFqInJavadoc : !useFqInCode) {
if (isShort) return element; // short name already, no need to change
}
PsiElement refElement;
if (!incompleteCode) {
refElement = ref.resolve();
} else {
PsiResolveHelper helper =
JavaPsiFacade.getInstance(ref.getManager().getProject()).getResolveHelper();
final SourceJavaCodeReference reference = (SourceJavaCodeReference) element;
refElement = helper.resolveReferencedClass(reference.getClassNameText(), ref);
}
if (refElement instanceof PsiClass) {
PsiClass psiClass = (PsiClass) refElement;
if (isInsideDocComment ? useFqInJavadoc : useFqInCode) {
String qName = psiClass.getQualifiedName();
if (qName == null) return element;
PsiFile file = ref.getContainingFile();
if (file instanceof PsiJavaFile) {
if (ImportHelper.isImplicitlyImported(qName, (PsiJavaFile) file)) {
if (isShort) return element;
return makeShortReference((CompositeElement) element, psiClass, addImports);
}
String thisPackageName = ((PsiJavaFile) file).getPackageName();
if (ImportHelper.hasPackage(qName, thisPackageName)) {
if (!isShort) {
return makeShortReference((CompositeElement) element, psiClass, addImports);
}
}
}
return replaceReferenceWithFQ(element, psiClass);
} else {
int oldLength = element.getTextLength();
ASTNode treeElement =
makeShortReference((CompositeElement) element, psiClass, addImports);
if (treeElement.getTextLength() == oldLength
&& psiClass.getContainingClass() != null) {
PsiElement qualifier = ref.getQualifier();
if (qualifier instanceof PsiJavaCodeReferenceElement
&& ((PsiJavaCodeReferenceElement) qualifier).resolve() instanceof PsiClass) {
process(
qualifier.getNode(), addImports, incompleteCode, useFqInJavadoc, useFqInCode);
}
}
return treeElement;
}
}
}
}
}
for (ASTNode child = element.getFirstChildNode(); child != null; child = child.getTreeNext()) {
//noinspection AssignmentToForLoopParameter
child = process(child, addImports, incompleteCode, useFqInJavadoc, useFqInCode);
}
return element;
}
private String[] suggestVariableNameByType(
final PsiType type,
final VariableKind variableKind,
final boolean correctKeywords,
boolean skipIndices) {
String longTypeName = skipIndices ? type.getCanonicalText() : getLongTypeName(type);
CodeStyleSettings.TypeToNameMap map = getMapByVariableKind(variableKind);
if (map != null && longTypeName != null) {
if (type.equals(PsiType.NULL)) {
longTypeName = CommonClassNames.JAVA_LANG_OBJECT;
}
String name = map.nameByType(longTypeName);
if (name != null && isIdentifier(name)) {
return new String[] {name};
}
}
final Collection<String> suggestions = new LinkedHashSet<String>();
final PsiClass psiClass =
!skipIndices && type instanceof PsiClassType ? ((PsiClassType) type).resolve() : null;
if (!skipIndices) {
suggestNamesForCollectionInheritors(type, variableKind, suggestions, correctKeywords);
if (psiClass != null
&& CommonClassNames.JAVA_UTIL_OPTIONAL.equals(psiClass.getQualifiedName())
&& ((PsiClassType) type).getParameterCount() == 1) {
PsiType optionalContent = ((PsiClassType) type).getParameters()[0];
Collections.addAll(
suggestions,
suggestVariableNameByType(optionalContent, variableKind, correctKeywords, false));
}
suggestNamesFromGenericParameters(type, variableKind, suggestions, correctKeywords);
}
String typeName = getTypeName(type, !skipIndices);
if (typeName != null) {
typeName = normalizeTypeName(typeName);
ContainerUtil.addAll(
suggestions,
getSuggestionsByName(
typeName, variableKind, type instanceof PsiArrayType, correctKeywords));
}
if (psiClass != null && psiClass.getContainingClass() != null) {
InheritanceUtil.processSupers(
psiClass,
false,
new Processor<PsiClass>() {
@Override
public boolean process(PsiClass superClass) {
if (PsiTreeUtil.isAncestor(superClass, psiClass, true)) {
ContainerUtil.addAll(
suggestions,
getSuggestionsByName(
superClass.getName(), variableKind, false, correctKeywords));
}
return false;
}
});
}
return ArrayUtil.toStringArray(suggestions);
}
private void checkExistingMethods(MultiMap<PsiElement, String> conflicts, boolean isGetter) {
if (isGetter) {
if (!myDescriptor.isToEncapsulateGet()) return;
} else {
if (!myDescriptor.isToEncapsulateSet()) return;
}
for (FieldDescriptor descriptor : myFieldDescriptors) {
PsiMethod prototype =
isGetter ? descriptor.getGetterPrototype() : descriptor.getSetterPrototype();
final PsiType prototypeReturnType = prototype.getReturnType();
PsiMethod existing = myClass.findMethodBySignature(prototype, true);
if (existing != null) {
final PsiType returnType = existing.getReturnType();
if (!RefactoringUtil.equivalentTypes(
prototypeReturnType, returnType, myClass.getManager())) {
final String descr =
PsiFormatUtil.formatMethod(
existing,
PsiSubstitutor.EMPTY,
PsiFormatUtilBase.SHOW_NAME
| PsiFormatUtilBase.SHOW_PARAMETERS
| PsiFormatUtilBase.SHOW_TYPE,
PsiFormatUtilBase.SHOW_TYPE);
String message =
isGetter
? RefactoringBundle.message(
"encapsulate.fields.getter.exists",
CommonRefactoringUtil.htmlEmphasize(descr),
CommonRefactoringUtil.htmlEmphasize(prototype.getName()))
: RefactoringBundle.message(
"encapsulate.fields.setter.exists",
CommonRefactoringUtil.htmlEmphasize(descr),
CommonRefactoringUtil.htmlEmphasize(prototype.getName()));
conflicts.putValue(existing, message);
}
} else {
PsiClass containingClass = myClass.getContainingClass();
while (containingClass != null && existing == null) {
existing = containingClass.findMethodBySignature(prototype, true);
if (existing != null) {
for (PsiReference reference : ReferencesSearch.search(existing)) {
final PsiElement place = reference.getElement();
LOG.assertTrue(place instanceof PsiReferenceExpression);
final PsiExpression qualifierExpression =
((PsiReferenceExpression) place).getQualifierExpression();
final PsiClass inheritor;
if (qualifierExpression == null) {
inheritor = PsiTreeUtil.getParentOfType(place, PsiClass.class, false);
} else {
inheritor = PsiUtil.resolveClassInType(qualifierExpression.getType());
}
if (InheritanceUtil.isInheritorOrSelf(inheritor, myClass, true)) {
conflicts.putValue(
existing,
"There is already a "
+ RefactoringUIUtil.getDescription(existing, true)
+ " which would be hidden by generated "
+ (isGetter ? "getter" : "setter"));
break;
}
}
}
containingClass = containingClass.getContainingClass();
}
}
}
}