private String format(PsiVariable variable, PsiModifierList modifierList) { String name = null; PsiElement parent = variable == null ? modifierList == null ? null : modifierList.getParent() : variable; if (parent instanceof PsiClass) { name = ((PsiClass) parent).getName(); } else { int options = PsiFormatUtilBase.SHOW_NAME | (myShowContainingClass ? PsiFormatUtilBase.SHOW_CONTAINING_CLASS : 0); if (parent instanceof PsiMethod) { name = PsiFormatUtil.formatMethod((PsiMethod) parent, PsiSubstitutor.EMPTY, options, 0); } else if (parent instanceof PsiVariable) { name = PsiFormatUtil.formatVariable((PsiVariable) parent, options, PsiSubstitutor.EMPTY); } else if (parent instanceof PsiClassInitializer) { PsiClass containingClass = ((PsiClassInitializer) parent).getContainingClass(); String className = containingClass instanceof PsiAnonymousClass ? QuickFixBundle.message( "anonymous.class.presentation", ((PsiAnonymousClass) containingClass).getBaseClassType().getPresentableText()) : containingClass != null ? containingClass.getName() : "unknown"; name = QuickFixBundle.message("class.initializer.presentation", className); } } String modifierText = VisibilityUtil.toPresentableText(myModifier); return QuickFixBundle.message( myShouldHave ? "add.modifier.fix" : "remove.modifier.fix", name, modifierText); }
public static void checkFieldConflicts( @Nullable PsiClass aClass, String newName, final Map<PsiElement, String> conflicts) { PsiField existingField = aClass != null ? aClass.findFieldByName(newName, true) : null; if (existingField != null) { if (aClass.equals(existingField.getContainingClass())) { String className = aClass instanceof PsiAnonymousClass ? RefactoringBundle.message("current.class") : RefactoringUIUtil.getDescription(aClass, false); final String conflict = RefactoringBundle.message( "field.0.is.already.defined.in.the.1", existingField.getName(), className); conflicts.put(existingField, conflict); } else { // method somewhere in base class if (!existingField.hasModifierProperty(PsiModifier.PRIVATE)) { String fieldInfo = PsiFormatUtil.formatVariable( existingField, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER, PsiSubstitutor.EMPTY); String className = RefactoringUIUtil.getDescription(existingField.getContainingClass(), false); final String descr = RefactoringBundle.message( "field.0.will.hide.field.1.of.the.base.class", newName, fieldInfo, className); conflicts.put(existingField, descr); } } } }
@NotNull @Override protected String getMemberPresentableText(PsiField field) { return PsiFormatUtil.formatVariable( field, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_FQ_NAME, PsiSubstitutor.EMPTY); }
@NotNull public String getText() { PsiLocalVariable variable = myOutOfScopeVariable; String varText = variable == null ? "" : PsiFormatUtil.formatVariable( variable, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE, PsiSubstitutor.EMPTY); return QuickFixBundle.message("bring.variable.to.scope.text", varText); }
public void updateReturnValueTemplate(PsiExpression expression) { if (myReturnValueTemplate == null) return; if (!getSuperMethods().isEmpty()) { for (final RefMethod refMethod : getSuperMethods()) { RefMethodImpl refSuper = (RefMethodImpl) refMethod; refSuper.updateReturnValueTemplate(expression); } } else { String newTemplate = null; final RefJavaUtil refUtil = RefJavaUtil.getInstance(); if (expression instanceof PsiLiteralExpression) { PsiLiteralExpression psiLiteralExpression = (PsiLiteralExpression) expression; newTemplate = psiLiteralExpression.getText(); } else if (expression instanceof PsiReferenceExpression) { PsiReferenceExpression referenceExpression = (PsiReferenceExpression) expression; PsiElement resolved = referenceExpression.resolve(); if (resolved instanceof PsiField) { PsiField psiField = (PsiField) resolved; if (psiField.hasModifierProperty(PsiModifier.STATIC) && psiField.hasModifierProperty(PsiModifier.FINAL) && refUtil.compareAccess(refUtil.getAccessModifier(psiField), getAccessModifier()) >= 0) { newTemplate = PsiFormatUtil.formatVariable( psiField, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_FQ_NAME, PsiSubstitutor.EMPTY); } } } else if (refUtil.isCallToSuperMethod(expression, (PsiMethod) getElement())) return; //noinspection StringEquality if (myReturnValueTemplate == RETURN_VALUE_UNDEFINED) { myReturnValueTemplate = newTemplate; } else if (!Comparing.equal(myReturnValueTemplate, newTemplate)) { myReturnValueTemplate = null; } } }
@Override @NotNull public String getNodeText(@NotNull PsiElement element, boolean useFullName) { if (element instanceof PsiDirectory) { return getPackageName((PsiDirectory) element, false); } if (element instanceof PsiPackage) { return getPackageName((PsiPackage) element); } if (element instanceof PsiFile) { return useFullName ? ((PsiFile) element).getVirtualFile().getPresentableUrl() : ((PsiFile) element).getName(); } if (element instanceof PsiLabeledStatement) { return ((PsiLabeledStatement) element).getLabelIdentifier().getText(); } if (ThrowSearchUtil.isSearchable(element)) { return ThrowSearchUtil.getSearchableTypeName(element); } if (element instanceof PsiClass) { String name = ((PsiClass) element).getQualifiedName(); if (name == null || !useFullName) { name = ((PsiClass) element).getName(); } if (name != null) return name; } if (element instanceof PsiMethod) { PsiMethod psiMethod = (PsiMethod) element; if (useFullName) { int options = PsiFormatUtilBase.TYPE_AFTER | PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS; String s = PsiFormatUtil.formatMethod( (PsiMethod) element, PsiSubstitutor.EMPTY, options, PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_NAME); return appendClassName(s, psiMethod.getContainingClass()); } else { int options = PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS; return PsiFormatUtil.formatMethod( psiMethod, PsiSubstitutor.EMPTY, options, PsiFormatUtilBase.SHOW_TYPE); } } if (element instanceof PsiParameter && ((PsiParameter) element).getDeclarationScope() instanceof PsiMethod) { PsiMethod method = (PsiMethod) ((PsiParameter) element).getDeclarationScope(); int varOptions = PsiFormatUtilBase.TYPE_AFTER | PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_NAME; int methodOptions = PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS; String s = LangBundle.message( "java.terms.variable.of.method", PsiFormatUtil.formatVariable((PsiVariable) element, varOptions, PsiSubstitutor.EMPTY), PsiFormatUtil.formatMethod( method, PsiSubstitutor.EMPTY, methodOptions, PsiFormatUtilBase.SHOW_TYPE)); return appendClassName(s, method.getContainingClass()); } if (element instanceof PsiField) { PsiField psiField = (PsiField) element; int options = PsiFormatUtilBase.TYPE_AFTER | PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_NAME; String s = PsiFormatUtil.formatVariable(psiField, options, PsiSubstitutor.EMPTY); return appendClassName(s, psiField.getContainingClass()); } if (element instanceof PsiVariable) { int options = PsiFormatUtilBase.TYPE_AFTER | PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_NAME; return PsiFormatUtil.formatVariable((PsiVariable) element, options, PsiSubstitutor.EMPTY); } return ""; }
@Override @NotNull public String getDescriptiveName(@NotNull final PsiElement element) { if (ThrowSearchUtil.isSearchable(element)) { return ThrowSearchUtil.getSearchableTypeName(element); } if (element instanceof PsiDirectory) { return getPackageName((PsiDirectory) element, false); } if (element instanceof PsiPackage) { return getPackageName((PsiPackage) element); } if (element instanceof PsiFile) { return ((PsiFile) element).getVirtualFile().getPresentableUrl(); } if (element instanceof PsiLabeledStatement) { return ((PsiLabeledStatement) element).getLabelIdentifier().getText(); } if (element instanceof PsiClass) { if (element instanceof PsiAnonymousClass) { String name = ((PsiAnonymousClass) element).getBaseClassReference().getReferenceName(); return "anonymous " + StringUtil.notNullize(name, "class"); } else { PsiClass aClass = (PsiClass) element; String qName = aClass.getQualifiedName(); return qName != null ? qName : aClass.getName() != null ? aClass.getName() : "<unknown>"; } } if (element instanceof PsiMethod) { PsiMethod psiMethod = (PsiMethod) element; String formatted = PsiFormatUtil.formatMethod( psiMethod, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_RAW_NON_TOP_TYPE); PsiClass psiClass = psiMethod.getContainingClass(); if (psiClass != null) { return getContainingClassDescription(psiClass, formatted); } return formatted; } if (element instanceof PsiField) { PsiField psiField = (PsiField) element; String formatted = PsiFormatUtil.formatVariable(psiField, PsiFormatUtilBase.SHOW_NAME, PsiSubstitutor.EMPTY); PsiClass psiClass = psiField.getContainingClass(); if (psiClass != null) { return getContainingClassDescription(psiClass, formatted); } return formatted; } if (element instanceof PsiVariable) { return PsiFormatUtil.formatVariable( (PsiVariable) element, PsiFormatUtilBase.SHOW_NAME, PsiSubstitutor.EMPTY); } if (element instanceof PsiLiteralExpression) { return element.getText(); } if (element instanceof PsiJavaModule) { return ((PsiJavaModule) element).getModuleName(); } return ""; }