From 739da034b54addb3cf58e3ff3ad01bec8fc852f9 Mon Sep 17 00:00:00 2001 From: UNV Date: Fri, 19 Dec 2025 13:45:43 +0300 Subject: [PATCH] Null-safe and localized RefJavaElementImpl.getName(). --- .../reference/RefClassImpl.java | 2 +- .../reference/RefJavaElementImpl.java | 493 ++++++++++-------- ...analysis.impl.JavaInspectionsLocalize.yaml | 38 +- 3 files changed, 291 insertions(+), 242 deletions(-) diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefClassImpl.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefClassImpl.java index d07fb8d71e..8164c08b91 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefClassImpl.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefClassImpl.java @@ -367,7 +367,7 @@ public void addTypeReference(RefJavaElement from) { myInTypeReferences = new HashSet<>(1); } myInTypeReferences.add(from); - ((RefJavaElementImpl) from).addOutTypeRefernce(this); + ((RefJavaElementImpl) from).addOutTypeReference(this); getRefManager().fireNodeMarkedReferenced(this, from, false, false, false); } } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefJavaElementImpl.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefJavaElementImpl.java index 9b98b3733b..b0ce4375f6 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefJavaElementImpl.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/reference/RefJavaElementImpl.java @@ -13,25 +13,24 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/* - * User: anna - * Date: 20-Dec-2007 - */ package com.intellij.java.analysis.impl.codeInspection.reference; import com.intellij.java.analysis.codeInspection.reference.*; import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.util.PsiFormatUtil; +import com.intellij.java.language.psi.util.PsiFormatUtilBase; import consulo.annotation.access.RequiredReadAction; import consulo.component.util.Iconable; +import consulo.java.analysis.impl.localize.JavaInspectionsLocalize; import consulo.language.editor.impl.inspection.reference.RefElementImpl; -import consulo.language.editor.inspection.localize.InspectionLocalize; import consulo.language.editor.inspection.reference.RefElement; import consulo.language.editor.inspection.reference.RefManager; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.PsiNamedElement; import consulo.language.psi.SyntheticElement; +import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.ui.image.Image; import consulo.util.collection.Stack; import consulo.virtualFileSystem.VirtualFileManager; @@ -43,269 +42,305 @@ import java.util.HashSet; import java.util.Set; +/** + * @author anna + * @since 2007-12-20 + */ public abstract class RefJavaElementImpl extends RefElementImpl implements RefJavaElement { - private Set myOutTypeReferences; - private static final int ACCESS_MODIFIER_MASK = 0x03; - private static final int ACCESS_PRIVATE = 0x00; - private static final int ACCESS_PROTECTED = 0x01; - private static final int ACCESS_PACKAGE = 0x02; - private static final int ACCESS_PUBLIC = 0x03; - private static final int IS_STATIC_MASK = 0x04; - private static final int IS_FINAL_MASK = 0x08; - private static final int IS_USES_DEPRECATION_MASK = 0x200; - private static final int IS_SYNTHETIC_JSP_ELEMENT = 0x400; - - protected RefJavaElementImpl(String name, RefJavaElement owner) { - super(name, owner); - String am = owner.getAccessModifier(); - doSetAccessModifier(am); - - final boolean synthOwner = owner.isSyntheticJSP(); - if (synthOwner) { - setSyntheticJSP(true); + private Set myOutTypeReferences; + private static final int ACCESS_MODIFIER_MASK = 0x03; + private static final int ACCESS_PRIVATE = 0x00; + private static final int ACCESS_PROTECTED = 0x01; + private static final int ACCESS_PACKAGE = 0x02; + private static final int ACCESS_PUBLIC = 0x03; + private static final int IS_STATIC_MASK = 0x04; + private static final int IS_FINAL_MASK = 0x08; + private static final int IS_USES_DEPRECATION_MASK = 0x200; + private static final int IS_SYNTHETIC_JSP_ELEMENT = 0x400; + + protected RefJavaElementImpl(String name, RefJavaElement owner) { + super(name, owner); + String am = owner.getAccessModifier(); + doSetAccessModifier(am); + + boolean synthOwner = owner.isSyntheticJSP(); + if (synthOwner) { + setSyntheticJSP(true); + } + } + + protected RefJavaElementImpl(PsiFile file, RefManager manager) { + super(file, manager); } - } - protected RefJavaElementImpl(PsiFile file, RefManager manager) { - super(file, manager); - } + @RequiredReadAction + protected RefJavaElementImpl(PsiModifierListOwner elem, RefManager manager) { + super(getName(elem).get(), elem, manager); - @RequiredReadAction - protected RefJavaElementImpl(PsiModifierListOwner elem, RefManager manager) { - super(getName(elem), elem, manager); + setAccessModifier(RefJavaUtil.getInstance().getAccessModifier(elem)); + boolean isSynth = elem instanceof PsiMethod && elem instanceof SyntheticElement || elem instanceof PsiSyntheticClass; + if (isSynth) { + setSyntheticJSP(true); + } - setAccessModifier(RefJavaUtil.getInstance().getAccessModifier(elem)); - final boolean isSynth = elem instanceof PsiMethod && elem instanceof SyntheticElement || elem instanceof PsiSyntheticClass; - if (isSynth) { - setSyntheticJSP(true); + setIsStatic(elem.hasModifierProperty(PsiModifier.STATIC)); + setIsFinal(elem.hasModifierProperty(PsiModifier.FINAL)); } - setIsStatic(elem.hasModifierProperty(PsiModifier.STATIC)); - setIsFinal(elem.hasModifierProperty(PsiModifier.FINAL)); - } + @Override + @Nonnull + public Collection getOutTypeReferences() { + if (myOutTypeReferences == null) { + return Collections.emptySet(); + } + return myOutTypeReferences; + } - @Override - @Nonnull - public Collection getOutTypeReferences() { - if (myOutTypeReferences == null) { - return Collections.emptySet(); + public void addOutTypeReference(RefClass refClass) { + if (myOutTypeReferences == null) { + myOutTypeReferences = new HashSet<>(); + } + myOutTypeReferences.add(refClass); } - return myOutTypeReferences; - } - public void addOutTypeRefernce(RefClass refClass) { - if (myOutTypeReferences == null) { - myOutTypeReferences = new HashSet<>(); + @RequiredReadAction + public static LocalizeValue getName(@Nonnull PsiElement element) { + if (element instanceof PsiAnonymousClass psiAnonymousClass) { + String name = psiAnonymousClass.getBaseClassType().resolve() instanceof PsiClass psiBaseClass ? psiBaseClass.getName() : null; + return name == null + ? JavaInspectionsLocalize.inspectionReferenceAnonymousClass() + : JavaInspectionsLocalize.inspectionReferenceAnonymousName(name); + } + + if (element instanceof PsiSyntheticClass jspClass) { + PsiFile jspxFile = jspClass.getContainingFile(); + return JavaInspectionsLocalize.inspectionReferenceJspSyntheticClassName(jspxFile.getName()); + } + + if (element instanceof PsiMethod method) { + if (element instanceof SyntheticElement) { + return JavaInspectionsLocalize.inspectionReferenceJspHolderMethodAnonymousName(); + } + + return LocalizeValue.of(PsiFormatUtil.formatMethod( + method, + PsiSubstitutor.EMPTY, + PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, + PsiFormatUtilBase.SHOW_TYPE + )); + } + + if (element instanceof PsiLambdaExpression || element instanceof PsiMethodReferenceExpression) { + boolean isMethodReference = element instanceof PsiMethodReferenceExpression; + PsiElement parentDeclaration = PsiTreeUtil.getParentOfType( + element, + PsiMethod.class, + PsiClass.class, + PsiLambdaExpression.class, + PsiField.class + ); + String name = parentDeclaration instanceof PsiNamedElement namedDeclaration ? namedDeclaration.getName() : null; + if (name != null) { + return isMethodReference + ? JavaInspectionsLocalize.inspectionReferenceMethodReferenceName(name) + : JavaInspectionsLocalize.inspectionReferenceLambdaName(name); + } + return isMethodReference + ? JavaInspectionsLocalize.inspectionReferenceDefaultMethodReferenceName() + : JavaInspectionsLocalize.inspectionReferenceDefaultLambdaName(); + } + + String name = element instanceof PsiNamedElement namedElement ? namedElement.getName() : null; + return name == null ? JavaInspectionsLocalize.inspectionReferenceAnonymous() : LocalizeValue.of(name); + } + + @Override + public boolean isFinal() { + return checkFlag(IS_FINAL_MASK); } - myOutTypeReferences.add(refClass); - } - - @RequiredReadAction - public static String getName(PsiElement element) { - if (element instanceof PsiAnonymousClass psiAnonymousClass) { - PsiClass psiBaseClass = psiAnonymousClass.getBaseClassType().resolve(); - return InspectionLocalize.inspectionReferenceAnonymousName(psiBaseClass == null ? "" : psiBaseClass.getQualifiedName()).get(); + + @Override + public boolean isStatic() { + return checkFlag(IS_STATIC_MASK); + } + + public void setIsStatic(boolean isStatic) { + setFlag(isStatic, IS_STATIC_MASK); } - if (element instanceof PsiSyntheticClass jspClass) { - final PsiFile jspxFile = jspClass.getContainingFile(); - return "<" + jspxFile.getName() + ">"; + @Override + public boolean isUsesDeprecatedApi() { + return checkFlag(IS_USES_DEPRECATION_MASK); } - if (element instanceof PsiMethod && element instanceof SyntheticElement) { - return InspectionLocalize.inspectionReferenceJspHolderMethodAnonymousName().get(); + public void setUsesDeprecatedApi(boolean usesDeprecatedApi) { + setFlag(usesDeprecatedApi, IS_USES_DEPRECATION_MASK); } - String name = null; - if (element instanceof PsiNamedElement namedElement) { - name = namedElement.getName(); + public void setIsFinal(boolean isFinal) { + setFlag(isFinal, IS_FINAL_MASK); } - return name == null ? InspectionLocalize.inspectionReferenceAnonymous().get() : name; - } - - @Override - public boolean isFinal() { - return checkFlag(IS_FINAL_MASK); - } - - @Override - public boolean isStatic() { - return checkFlag(IS_STATIC_MASK); - } - - public void setIsStatic(boolean isStatic) { - setFlag(isStatic, IS_STATIC_MASK); - } - - @Override - public boolean isUsesDeprecatedApi() { - return checkFlag(IS_USES_DEPRECATION_MASK); - } - - public void setUsesDeprecatedApi(boolean usesDeprecatedApi) { - setFlag(usesDeprecatedApi, IS_USES_DEPRECATION_MASK); - } - - public void setIsFinal(boolean isFinal) { - setFlag(isFinal, IS_FINAL_MASK); - } - - public void setReachable(boolean reachable) { - setFlag(reachable, IS_REACHABLE_MASK); - } - - @Override - public boolean isSyntheticJSP() { - return checkFlag(IS_SYNTHETIC_JSP_ELEMENT); - } - - public void setSyntheticJSP(boolean b) { - setFlag(b, IS_SYNTHETIC_JSP_ELEMENT); - } - - @Override - @Nullable - public String getAccessModifier() { - long access_id = myFlags & ACCESS_MODIFIER_MASK; - if (access_id == ACCESS_PRIVATE) { - return PsiModifier.PRIVATE; + @Override + public void setReachable(boolean reachable) { + setFlag(reachable, IS_REACHABLE_MASK); } - if (access_id == ACCESS_PUBLIC) { - return PsiModifier.PUBLIC; + + @Override + public boolean isSyntheticJSP() { + return checkFlag(IS_SYNTHETIC_JSP_ELEMENT); } - if (access_id == ACCESS_PACKAGE) { - return PsiModifier.PACKAGE_LOCAL; + + public void setSyntheticJSP(boolean b) { + setFlag(b, IS_SYNTHETIC_JSP_ELEMENT); } - return PsiModifier.PROTECTED; - } - - public void setAccessModifier(String am) { - doSetAccessModifier(am); - } - - private void doSetAccessModifier(String am) { - final int access_id; - - switch (am) { - case PsiModifier.PRIVATE: - access_id = ACCESS_PRIVATE; - break; - case PsiModifier.PUBLIC: - access_id = ACCESS_PUBLIC; - break; - case PsiModifier.PACKAGE_LOCAL: - access_id = ACCESS_PACKAGE; - break; - default: - access_id = ACCESS_PROTECTED; - break; + + @Override + @Nullable + public String getAccessModifier() { + long accessId = myFlags & ACCESS_MODIFIER_MASK; + if (accessId == ACCESS_PRIVATE) { + return PsiModifier.PRIVATE; + } + if (accessId == ACCESS_PUBLIC) { + return PsiModifier.PUBLIC; + } + if (accessId == ACCESS_PACKAGE) { + return PsiModifier.PACKAGE_LOCAL; + } + return PsiModifier.PROTECTED; } - myFlags = myFlags & ~0x3 | access_id; - } + public void setAccessModifier(String am) { + doSetAccessModifier(am); + } - public boolean isSuspiciousRecursive() { - return isCalledOnlyFrom(this, new Stack<>()); - } + private void doSetAccessModifier(String am) { + int accessId = switch (am) { + case PsiModifier.PRIVATE -> ACCESS_PRIVATE; + case PsiModifier.PUBLIC -> ACCESS_PUBLIC; + case PsiModifier.PACKAGE_LOCAL -> ACCESS_PACKAGE; + default -> ACCESS_PROTECTED; + }; - private boolean isCalledOnlyFrom(RefJavaElement refElement, Stack callStack) { - if (callStack.contains(this)) { - return refElement == this; + myFlags = myFlags & ~0x3 | accessId; } - if (getInReferences().isEmpty()) { - return false; + + public boolean isSuspiciousRecursive() { + return isCalledOnlyFrom(this, new Stack<>()); } - if (refElement instanceof RefMethod refMethod) { - for (RefMethod refSuper : refMethod.getSuperMethods()) { - if (!refSuper.getInReferences().isEmpty()) { - return false; + private boolean isCalledOnlyFrom(RefJavaElement refElement, Stack callStack) { + if (callStack.contains(this)) { + return refElement == this; } - } - if (refMethod.isConstructor()) { - boolean unreachable = true; - for (RefElement refOut : refMethod.getOutReferences()) { - unreachable &= !refOut.isReachable(); + if (getInReferences().isEmpty()) { + return false; } - if (unreachable) { - return true; + + if (refElement instanceof RefMethod refMethod) { + for (RefMethod refSuper : refMethod.getSuperMethods()) { + if (!refSuper.getInReferences().isEmpty()) { + return false; + } + } + if (refMethod.isConstructor()) { + boolean unreachable = true; + for (RefElement refOut : refMethod.getOutReferences()) { + unreachable &= !refOut.isReachable(); + } + if (unreachable) { + return true; + } + } + } + + callStack.push(this); + for (RefElement refCaller : getInReferences()) { + if (!((RefElementImpl) refCaller).isSuspicious() || !((RefJavaElementImpl) refCaller).isCalledOnlyFrom(refElement, callStack)) { + callStack.pop(); + return false; + } } - } - } - callStack.push(this); - for (RefElement refCaller : getInReferences()) { - if (!((RefElementImpl) refCaller).isSuspicious() || !((RefJavaElementImpl) refCaller).isCalledOnlyFrom(refElement, callStack)) { callStack.pop(); - return false; - } + return true; } - callStack.pop(); - return true; - } - - public void addReference(RefElement refWhat, PsiElement psiWhat, PsiElement psiFrom, boolean forWriting, boolean forReading, PsiReferenceExpression expression) { - if (refWhat != null) { - if (refWhat instanceof RefParameter refParameter) { - if (forWriting) { - refParameter.parameterReferenced(true); - } - // TODO: else if? - if (forReading) { - refParameter.parameterReferenced(false); + public void addReference( + RefElement refWhat, + PsiElement psiWhat, + PsiElement psiFrom, + boolean forWriting, + boolean forReading, + PsiReferenceExpression expression + ) { + if (refWhat != null) { + if (refWhat instanceof RefParameter refParameter) { + if (forWriting) { + refParameter.parameterReferenced(true); + } + // TODO: else if? + if (forReading) { + refParameter.parameterReferenced(false); + } + } + addOutReference(refWhat); + ((RefJavaElementImpl) refWhat).markReferenced(this, psiFrom, psiWhat, forWriting, forReading, expression); } - } - addOutReference(refWhat); - ((RefJavaElementImpl) refWhat).markReferenced(this, psiFrom, psiWhat, forWriting, forReading, expression); - } else { - if (psiWhat instanceof PsiMethod method) { - final PsiClass containingClass = method.getContainingClass(); - if (containingClass != null && containingClass.isEnum() && "values".equals(method.getName())) { - for (PsiField enumConstant : containingClass.getFields()) { - if (enumConstant instanceof PsiEnumConstant) { - final RefJavaElementImpl enumConstantReference = (RefJavaElementImpl) getRefManager().getReference(enumConstant); - if (enumConstantReference != null) { - addOutReference(enumConstantReference); - enumConstantReference.markReferenced(this, psiFrom, enumConstant, false, true, expression); - } + else if (psiWhat instanceof PsiMethod method) { + PsiClass containingClass = method.getContainingClass(); + if (containingClass != null && containingClass.isEnum() && "values".equals(method.getName())) { + for (PsiField enumConstant : containingClass.getFields()) { + if (enumConstant instanceof PsiEnumConstant) { + RefJavaElementImpl enumConstantReference = (RefJavaElementImpl) getRefManager().getReference(enumConstant); + if (enumConstantReference != null) { + addOutReference(enumConstantReference); + enumConstantReference.markReferenced(this, psiFrom, enumConstant, false, true, expression); + } + } + } } - } } - } } - } - - protected void markReferenced(final RefElementImpl refFrom, PsiElement psiFrom, PsiElement psiWhat, final boolean forWriting, boolean forReading, PsiReferenceExpression expressionFrom) { - addInReference(refFrom); - getRefManager().fireNodeMarkedReferenced(this, refFrom, false, forReading, forWriting); - } - - protected RefJavaManager getRefJavaManager() { - return getRefManager().getExtension(RefJavaManager.MANAGER); - } - - @Override - public void referenceRemoved() { - super.referenceRemoved(); - if (isEntry()) { - getRefJavaManager().getEntryPointsManager().removeEntryPoint(this); + + protected void markReferenced( + RefElementImpl refFrom, + PsiElement psiFrom, + PsiElement psiWhat, + boolean forWriting, + boolean forReading, + PsiReferenceExpression expressionFrom + ) { + addInReference(refFrom); + getRefManager().fireNodeMarkedReferenced(this, refFrom, false, forReading, forWriting); + } + + protected RefJavaManager getRefJavaManager() { + return getRefManager().getExtension(RefJavaManager.MANAGER); } - } - - @Override - public Image getIcon(final boolean expanded) { - if (isSyntheticJSP()) { - final PsiElement element = getPsiElement(); - if (element != null && element.isValid()) { - return VirtualFileManager.getInstance().getFileIcon( - element.getContainingFile().getVirtualFile(), - element.getProject(), - Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS - ); - } + + @Override + public void referenceRemoved() { + super.referenceRemoved(); + if (isEntry()) { + getRefJavaManager().getEntryPointsManager().removeEntryPoint(this); + } + } + + @Override + @RequiredReadAction + public Image getIcon(boolean expanded) { + if (isSyntheticJSP()) { + PsiElement element = getPsiElement(); + if (element != null && element.isValid()) { + return VirtualFileManager.getInstance().getFileIcon( + element.getContainingFile().getVirtualFile(), + element.getProject(), + Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS + ); + } + } + return super.getIcon(expanded); } - return super.getIcon(expanded); - } } diff --git a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml index dcec36dd90..c263d2ca61 100644 --- a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml +++ b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaInspectionsLocalize.yaml @@ -464,20 +464,12 @@ inspection.data.flow.display.name: text: Constant conditions & exceptions inspection.data.flow.filter.notnull.quickfix: text: Insert 'filter(Objects::nonNull)' step +inspection.data.flow.ignore.assert.statements: + text: Ignore assert statements inspection.data.flow.nullable.quickfix.option: text: Suggest @Nullable annotation for methods that may possibly return null and report nullable values passed to non-annotated parameters inspection.data.flow.redundant.instanceof.quickfix: text: Replace with != null -inspection.data.flow.simplify.boolean.expression.quickfix: - text: Simplify boolean expression -inspection.data.flow.simplify.to.assignment.quickfix.name: - text: Simplify to normal assignment -inspection.data.flow.true.asserts.option: - text: Don't report assertions with condition statically proven to be always true -inspection.data.flow.ignore.assert.statements: - text: Ignore assert statements -inspection.data.flow.treat.non.annotated.members.and.parameters.as.nullable: - text: Treat non-annotated members and parameters as @Nullable inspection.data.flow.report.constant.reference.values: text: Warn when reading a value guaranteed to be constant inspection.data.flow.report.not.null.required.parameter.with.null.literal.argument.usages: @@ -486,6 +478,14 @@ inspection.data.flow.report.nullable.methods.that.always.return.a.non.null.value text: Report nullable methods that always return a non-null value inspection.data.flow.report.problems.that.happen.only.on.some.code.paths: text: Report problems that happen only on some code paths +inspection.data.flow.simplify.boolean.expression.quickfix: + text: Simplify boolean expression +inspection.data.flow.simplify.to.assignment.quickfix.name: + text: Simplify to normal assignment +inspection.data.flow.treat.non.annotated.members.and.parameters.as.nullable: + text: Treat non-annotated members and parameters as @Nullable +inspection.data.flow.true.asserts.option: + text: Don't report assertions with condition statically proven to be always true inspection.data.flow.use.computeifpresent.quickfix: text: Replace 'compute' with 'computeIfPresent' inspection.dead.code.comment: @@ -932,6 +932,8 @@ inspection.map.foreach.option.no.loops: text: Do not report loops inspection.marked.for.removal.display.name: text: Usage of API marked for removal +inspection.message.redundant.default.parameter.value.assignment: + text: Redundant default parameter value assignment inspection.module.exports.package.to.itself: text: Module exports/opens package to itself inspection.new.profile.dialog.title: @@ -1098,16 +1100,30 @@ inspection.redundant.type.remove.quickfix: text: Remove explicit type arguments inspection.reference.anonymous: text: anonymous +inspection.reference.anonymous.class: + text: anonymous class inspection.reference.anonymous.name: text: anonymous ({0}) +inspection.reference.default.lambda.name: + text: lambda +inspection.reference.default.method.reference.name: + text: method reference inspection.reference.default.package: text: +inspection.reference.implicit.class: + text: compact source file ''{0}'' inspection.reference.implicit.constructor.name: text: implicit constructor of {0} inspection.reference.invalid: text: element no longer exists inspection.reference.jsp.holder.method.anonymous.name: text: <% page content %> +inspection.reference.jsp.synthetic.class.name: + text: <{0}> +inspection.reference.lambda.name: + text: lambda ({0}) +inspection.reference.method.reference.name: + text: method reference ({0}) inspection.reference.noname: text: noname inspection.reflect.handle.invocation.argument.not.array: @@ -1592,5 +1608,3 @@ xml.suppressable.for.file.title: text: Suppress for file xml.suppressable.for.tag.title: text: Suppress for tag -inspection.message.redundant.default.parameter.value.assignment: - text: Redundant default parameter value assignment \ No newline at end of file