private static void addDefaultConstructor(
JavaChangeInfo changeInfo, PsiClass aClass, final UsageInfo[] usages)
throws IncorrectOperationException {
if (!(aClass instanceof PsiAnonymousClass)) {
PsiElementFactory factory = JavaPsiFacade.getElementFactory(aClass.getProject());
PsiMethod defaultConstructor =
factory.createMethodFromText(aClass.getName() + "(){}", aClass);
defaultConstructor =
(PsiMethod)
CodeStyleManager.getInstance(aClass.getProject()).reformat(defaultConstructor);
defaultConstructor = (PsiMethod) aClass.add(defaultConstructor);
PsiUtil.setModifierProperty(
defaultConstructor, VisibilityUtil.getVisibilityModifier(aClass.getModifierList()), true);
addSuperCall(changeInfo, defaultConstructor, null, usages);
} else {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiNewExpression) {
final PsiExpressionList argumentList = ((PsiNewExpression) parent).getArgumentList();
final PsiClass baseClass = changeInfo.getMethod().getContainingClass();
final PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
fixActualArgumentsList(argumentList, changeInfo, true, substitutor);
}
}
}
public static boolean isInside(PsiElement place, PsiElement ancestor) {
if (SafeDeleteProcessor.isInside(place, ancestor)) return true;
if (PsiTreeUtil.getParentOfType(place, PsiComment.class, false) != null
&& ancestor instanceof PsiClass) {
final PsiClass aClass = (PsiClass) ancestor;
if (aClass.getParent() instanceof PsiJavaFile) {
final PsiJavaFile file = (PsiJavaFile) aClass.getParent();
if (PsiTreeUtil.isAncestor(file, place, false)) {
if (file.getClasses().length == 1) { // file will be deleted on class deletion
return true;
}
}
}
}
return false;
}
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 int findOffsetToInsertMethodTo(Editor editor, PsiFile file) {
int result = editor.getCaretModel().getOffset();
PsiClass classAtCursor =
PsiTreeUtil.getParentOfType(file.findElementAt(result), PsiClass.class, false);
while (classAtCursor != null && !(classAtCursor.getParent() instanceof PsiFile)) {
result = classAtCursor.getTextRange().getEndOffset();
classAtCursor = PsiTreeUtil.getParentOfType(classAtCursor, PsiClass.class);
}
return result;
}
private static int getSeqNumber(@NotNull PsiClass aClass) {
// sequence number of this class among its parent' child classes named the same
PsiElement parent = aClass.getParent();
if (parent == null) return -1;
int seqNo = 0;
for (PsiElement child : parent.getChildren()) {
if (child == aClass) return seqNo;
if (child instanceof PsiClass
&& Comparing.strEqual(aClass.getName(), ((PsiClass) child).getName())) {
seqNo++;
}
}
return -1;
}
private static String replaceDotsWithDollars(final String qName, PsiClass aClass) {
StringBuilder qNameBuffer = new StringBuilder(qName);
int fromIndex = qNameBuffer.length();
PsiElement parent = aClass.getParent();
while (parent instanceof PsiClass) {
final int dotIndex = qNameBuffer.lastIndexOf(".", fromIndex);
if (dotIndex < 0) break;
qNameBuffer.replace(dotIndex, dotIndex + 1, "$");
fromIndex = dotIndex - 1;
parent = parent.getParent();
}
return qNameBuffer.toString();
}
@NotNull
@Override
public PsiImportStatement createImportStatement(@NotNull final PsiClass aClass)
throws IncorrectOperationException {
if (aClass instanceof PsiAnonymousClass) {
throw new IncorrectOperationException("Cannot create import statement for anonymous class.");
} else if (aClass.getParent() instanceof PsiDeclarationStatement) {
throw new IncorrectOperationException("Cannot create import statement for local class.");
}
final PsiJavaFile aFile = createDummyJavaFile("import " + aClass.getQualifiedName() + ";");
final PsiImportStatementBase statement = extractImport(aFile, false);
return (PsiImportStatement)
CodeStyleManager.getInstance(myManager.getProject()).reformat(statement);
}
public static Set<String> getAllLookupStrings(@NotNull PsiMember member) {
Set<String> allLookupStrings = ContainerUtil.newLinkedHashSet();
String name = member.getName();
allLookupStrings.add(name);
PsiClass containingClass = member.getContainingClass();
while (containingClass != null) {
final String className = containingClass.getName();
if (className == null) {
break;
}
name = className + "." + name;
allLookupStrings.add(name);
final PsiElement parent = containingClass.getParent();
if (!(parent instanceof PsiClass)) {
break;
}
containingClass = (PsiClass) parent;
}
return allLookupStrings;
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementForWrite(descriptor.getPsiElement())) return;
final PsiModifierListOwner element =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiModifierListOwner.class);
if (element != null) {
RefElement refElement = null;
if (myManager != null) {
refElement = myManager.getReference(element);
}
try {
if (element instanceof PsiVariable) {
((PsiVariable) element).normalizeDeclaration();
}
PsiModifierList list = element.getModifierList();
LOG.assertTrue(list != null);
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& containingClass.getParent() instanceof PsiFile
&& myHint == PsiModifier.PRIVATE
&& list.hasModifierProperty(PsiModifier.FINAL)) {
list.setModifierProperty(PsiModifier.FINAL, false);
}
}
list.setModifierProperty(myHint, true);
if (refElement instanceof RefJavaElement) {
RefJavaUtil.getInstance().setAccessModifier((RefJavaElement) refElement, myHint);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
public PsiClass getParentClass(@NotNull PsiExpression initializerExpression) {
final PsiType type = initializerExpression.getType();
if (type != null && PsiUtil.isConstantExpression(initializerExpression)) {
if (type instanceof PsiPrimitiveType
|| PsiType.getJavaLangString(
initializerExpression.getManager(), initializerExpression.getResolveScope())
.equals(type)) {
return super.getParentClass(initializerExpression);
}
}
PsiElement parent = initializerExpression.getUserData(ElementToWorkOn.PARENT);
if (parent == null) parent = initializerExpression;
PsiClass aClass = PsiTreeUtil.getParentOfType(parent, PsiClass.class);
while (aClass != null) {
if (aClass.hasModifierProperty(PsiModifier.STATIC)) return aClass;
if (aClass.getParent() instanceof PsiJavaFile) return aClass;
aClass = PsiTreeUtil.getParentOfType(aClass, PsiClass.class);
}
return null;
}
@Nullable
private Collection<DfaMemoryState> createInitialStates(
@NotNull PsiElement psiBlock, InstructionVisitor visitor) {
PsiClass containingClass = PsiTreeUtil.getParentOfType(psiBlock, PsiClass.class);
if (containingClass != null && PsiUtil.isLocalOrAnonymousClass(containingClass)) {
final PsiElement parent = containingClass.getParent();
final PsiCodeBlock block = DfaPsiUtil.getTopmostBlockInSameClass(parent);
if ((parent instanceof PsiNewExpression || parent instanceof PsiDeclarationStatement)
&& block != null) {
final RunnerResult result = analyzeMethod(block, visitor);
if (result == RunnerResult.OK) {
final Collection<DfaMemoryState> closureStates =
myNestedClosures.get(DfaPsiUtil.getTopmostBlockInSameClass(psiBlock));
if (!closureStates.isEmpty()) {
return closureStates;
}
}
return null;
}
}
return Arrays.asList(createMemoryState());
}
private void buildText(
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull StringBuilder buffer,
@NotNull TextType textType,
boolean annotated) {
if (aClass instanceof PsiAnonymousClass) {
ClassResolveResult baseResolveResult =
((PsiAnonymousClass) aClass).getBaseClassType().resolveGenerics();
PsiClass baseClass = baseResolveResult.getElement();
if (baseClass != null) {
buildText(baseClass, baseResolveResult.getSubstitutor(), buffer, textType, false);
}
return;
}
boolean qualified = textType != TextType.PRESENTABLE;
PsiClass enclosingClass = null;
if (!aClass.hasModifierProperty(PsiModifier.STATIC)) {
PsiElement parent = aClass.getParent();
if (parent instanceof PsiClass && !(parent instanceof PsiAnonymousClass)) {
enclosingClass = (PsiClass) parent;
}
}
if (enclosingClass != null) {
buildText(enclosingClass, substitutor, buffer, textType, false);
buffer.append('.');
} else if (qualified) {
String fqn = aClass.getQualifiedName();
if (fqn != null) {
String prefix = StringUtil.getPackageName(fqn);
if (!StringUtil.isEmpty(prefix)) {
buffer.append(prefix);
buffer.append('.');
}
}
}
if (annotated) {
PsiNameHelper.appendAnnotations(buffer, getAnnotations(), qualified);
}
buffer.append(aClass.getName());
PsiTypeParameter[] typeParameters = aClass.getTypeParameters();
if (typeParameters.length > 0) {
int pos = buffer.length();
buffer.append('<');
for (int i = 0; i < typeParameters.length; i++) {
PsiTypeParameter typeParameter = typeParameters[i];
PsiUtilCore.ensureValid(typeParameter);
if (i > 0) {
buffer.append(',');
if (textType == TextType.PRESENTABLE) buffer.append(' ');
}
PsiType substitutionResult = substitutor.substitute(typeParameter);
if (substitutionResult == null) {
buffer.setLength(pos);
pos = -1;
break;
}
PsiUtil.ensureValidType(substitutionResult);
if (textType == TextType.PRESENTABLE) {
buffer.append(substitutionResult.getPresentableText());
} else if (textType == TextType.CANONICAL) {
buffer.append(substitutionResult.getCanonicalText(annotated));
} else {
buffer.append(substitutionResult.getInternalCanonicalText());
}
}
if (pos >= 0) {
buffer.append('>');
}
}
}
private void buildText(
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull StringBuilder buffer,
boolean canonical,
boolean internal) {
if (aClass instanceof PsiAnonymousClass) {
ClassResolveResult baseResolveResult =
((PsiAnonymousClass) aClass).getBaseClassType().resolveGenerics();
PsiClass baseClass = baseResolveResult.getElement();
PsiSubstitutor baseSub = baseResolveResult.getSubstitutor();
if (baseClass != null) {
buildText(baseClass, baseSub, buffer, canonical, internal);
}
return;
}
if (canonical == internal) {
buffer.append(getAnnotationsTextPrefix(internal, false, true));
}
PsiClass enclosingClass = null;
if (!aClass.hasModifierProperty(PsiModifier.STATIC)) {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiClass && !(parent instanceof PsiAnonymousClass)) {
enclosingClass = (PsiClass) parent;
}
}
if (enclosingClass != null) {
buildText(enclosingClass, substitutor, buffer, canonical, false);
buffer.append('.');
buffer.append(aClass.getName());
} else {
final String name;
if (!canonical) {
name = aClass.getName();
} else {
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null) {
name = aClass.getName();
} else {
name = qualifiedName;
}
}
buffer.append(name);
}
PsiTypeParameter[] typeParameters = aClass.getTypeParameters();
if (typeParameters.length > 0) {
StringBuilder pineBuffer = new StringBuilder();
pineBuffer.append('<');
for (int i = 0; i < typeParameters.length; i++) {
PsiTypeParameter typeParameter = typeParameters[i];
assert typeParameter.isValid();
if (i > 0) pineBuffer.append(',');
final PsiType substitutionResult = substitutor.substitute(typeParameter);
if (substitutionResult == null) {
pineBuffer = null;
break;
}
assert substitutionResult.isValid();
if (canonical) {
if (internal) {
pineBuffer.append(substitutionResult.getInternalCanonicalText());
} else {
pineBuffer.append(substitutionResult.getCanonicalText());
}
} else {
pineBuffer.append(substitutionResult.getPresentableText());
}
}
if (pineBuffer != null) {
buffer.append(pineBuffer);
buffer.append('>');
}
}
}
protected void initialize() {
myDefaultConstructor = null;
final PsiClass psiClass = getElement();
LOG.assertTrue(psiClass != null);
PsiElement psiParent = psiClass.getParent();
if (psiParent instanceof PsiFile) {
if (isSyntheticJSP()) {
final RefFileImpl refFile =
(RefFileImpl) getRefManager().getReference(JspPsiUtil.getJspFile(psiClass));
LOG.assertTrue(refFile != null);
refFile.add(this);
} else if (psiParent instanceof PsiJavaFile) {
PsiJavaFile psiFile = (PsiJavaFile) psiParent;
String packageName = psiFile.getPackageName();
if (!"".equals(packageName)) {
((RefPackageImpl) getRefJavaManager().getPackage(packageName)).add(this);
} else {
((RefPackageImpl) getRefJavaManager().getDefaultPackage()).add(this);
}
}
final Module module = ModuleUtil.findModuleForPsiElement(psiClass);
LOG.assertTrue(module != null);
final RefModuleImpl refModule = ((RefModuleImpl) getRefManager().getRefModule(module));
LOG.assertTrue(refModule != null);
refModule.add(this);
} else {
while (!(psiParent instanceof PsiClass
|| psiParent instanceof PsiMethod
|| psiParent instanceof PsiField)) {
psiParent = psiParent.getParent();
}
RefElement refParent = getRefManager().getReference(psiParent);
LOG.assertTrue(refParent != null);
((RefElementImpl) refParent).add(this);
}
setAbstract(psiClass.hasModifierProperty(PsiModifier.ABSTRACT));
setAnonymous(psiClass instanceof PsiAnonymousClass);
setIsLocal(!(isAnonymous() || psiParent instanceof PsiClass || psiParent instanceof PsiFile));
setInterface(psiClass.isInterface());
initializeSuperReferences(psiClass);
PsiMethod[] psiMethods = psiClass.getMethods();
PsiField[] psiFields = psiClass.getFields();
setUtilityClass(psiMethods.length > 0 || psiFields.length > 0);
for (PsiField psiField : psiFields) {
getRefManager().getReference(psiField);
}
if (!isApplet()) {
final PsiClass servlet = getRefJavaManager().getServlet();
setServlet(servlet != null && psiClass.isInheritor(servlet, true));
}
if (!isApplet() && !isServlet()) {
setTestCase(TestUtil.isTestClass(psiClass));
for (RefClass refBase : getBaseClasses()) {
((RefClassImpl) refBase).setTestCase(true);
}
}
for (PsiMethod psiMethod : psiMethods) {
RefMethod refMethod = (RefMethod) getRefManager().getReference(psiMethod);
if (refMethod != null) {
if (psiMethod.isConstructor()) {
if (psiMethod.getParameterList().getParametersCount() > 0
|| !psiMethod.hasModifierProperty(PsiModifier.PRIVATE)) {
setUtilityClass(false);
}
addConstructor(refMethod);
if (psiMethod.getParameterList().getParametersCount() == 0) {
setDefaultConstructor((RefMethodImpl) refMethod);
}
} else {
if (!psiMethod.hasModifierProperty(PsiModifier.STATIC)) {
setUtilityClass(false);
}
}
}
}
if (getConstructors().size() == 0 && !isInterface() && !isAnonymous()) {
RefImplicitConstructorImpl refImplicitConstructor = new RefImplicitConstructorImpl(this);
setDefaultConstructor(refImplicitConstructor);
addConstructor(refImplicitConstructor);
}
if (isInterface()) {
for (int i = 0; i < psiFields.length && isUtilityClass(); i++) {
PsiField psiField = psiFields[i];
if (!psiField.hasModifierProperty(PsiModifier.STATIC)) {
setUtilityClass(false);
}
}
}
final PsiClass applet = getRefJavaManager().getApplet();
setApplet(applet != null && psiClass.isInheritor(applet, true));
getRefManager().fireNodeInitialized(this);
}