From 4a27bdccbecac816170fbfc70ebc78793e448e75 Mon Sep 17 00:00:00 2001 From: UNV Date: Fri, 5 Dec 2025 00:48:12 +0300 Subject: [PATCH] Updating localization in JavaElementKind. Using separate keys for nominative and accusative names. --- .../intention/AddAnnotationFix.java | 53 ++++---- .../language/psi/util/JavaElementKind.java | 81 +++++------ ...lo.java.language.JavaLanguageLocalize.yaml | 128 +++++++++++++----- 3 files changed, 167 insertions(+), 95 deletions(-) diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationFix.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationFix.java index 7c83857f2b..7792aa5cc0 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationFix.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationFix.java @@ -13,47 +13,52 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package com.intellij.java.analysis.impl.codeInsight.intention; import com.intellij.java.language.psi.PsiModifierListOwner; import com.intellij.java.language.psi.PsiNameValuePair; +import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; import consulo.language.editor.intention.SyntheticIntentionAction; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import jakarta.annotation.Nonnull; /** * @author ven */ -public class AddAnnotationFix extends AddAnnotationPsiFix implements SyntheticIntentionAction -{ - public AddAnnotationFix(@Nonnull String fqn, @Nonnull PsiModifierListOwner modifierListOwner, @Nonnull String... annotationsToRemove) { - this(fqn, modifierListOwner, PsiNameValuePair.EMPTY_ARRAY, annotationsToRemove); - } +public class AddAnnotationFix extends AddAnnotationPsiFix implements SyntheticIntentionAction { + @RequiredReadAction + public AddAnnotationFix(@Nonnull String fqn, @Nonnull PsiModifierListOwner modifierListOwner, @Nonnull String... annotationsToRemove) { + this(fqn, modifierListOwner, PsiNameValuePair.EMPTY_ARRAY, annotationsToRemove); + } - public AddAnnotationFix(@Nonnull String fqn, - @Nonnull PsiModifierListOwner modifierListOwner, - @Nonnull PsiNameValuePair[] values, - @Nonnull String... annotationsToRemove) { - super(fqn, modifierListOwner, values, annotationsToRemove); - } + @RequiredReadAction + public AddAnnotationFix( + @Nonnull String fqn, + @Nonnull PsiModifierListOwner modifierListOwner, + @Nonnull PsiNameValuePair[] values, + @Nonnull String... annotationsToRemove + ) { + super(fqn, modifierListOwner, values, annotationsToRemove); + } - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { - return isAvailable(); - } + @Override + @RequiredUIAccess + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return isAvailable(); + } - @Override - public void invoke(@Nonnull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { - applyFix(); - } + @Override + public void invoke(@Nonnull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { + applyFix(); + } - @Override - public boolean startInWriteAction() { - return true; - } + @Override + public boolean startInWriteAction() { + return true; + } } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/util/JavaElementKind.java b/java-language-api/src/main/java/com/intellij/java/language/psi/util/JavaElementKind.java index 4514ebb630..3a57a4b937 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/util/JavaElementKind.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/util/JavaElementKind.java @@ -13,51 +13,54 @@ * The main purpose of this enum is to be able to display localized element name in UI */ public enum JavaElementKind { - ABSTRACT_METHOD(JavaLanguageLocalize.elementAbstract_method()), - ANNOTATION(JavaLanguageLocalize.elementAnnotation()), - ANONYMOUS_CLASS(JavaLanguageLocalize.elementAnonymous_class()), - CLASS(JavaLanguageLocalize.elementClass()), - TYPE_PARAMETER(JavaLanguageLocalize.elementTypeParameter()), - CONSTANT(JavaLanguageLocalize.elementConstant()), - CONSTRUCTOR(JavaLanguageLocalize.elementConstructor()), - ENUM(JavaLanguageLocalize.elementEnum()), - ENUM_CONSTANT(JavaLanguageLocalize.elementEnum_constant()), - EXPRESSION(JavaLanguageLocalize.elementExpression()), - FIELD(JavaLanguageLocalize.elementField()), - INITIALIZER(JavaLanguageLocalize.elementInitializer()), - INTERFACE(JavaLanguageLocalize.elementInterface()), - LABEL(JavaLanguageLocalize.elementLabel()), - LOCAL_VARIABLE(JavaLanguageLocalize.elementLocal_variable()), - METHOD(JavaLanguageLocalize.elementMethod()), - MODULE(JavaLanguageLocalize.elementModule()), - PACKAGE(JavaLanguageLocalize.elementPackage()), - PARAMETER(JavaLanguageLocalize.elementParameter()), - PATTERN_VARIABLE(JavaLanguageLocalize.elementPattern_variable()), - RECORD(JavaLanguageLocalize.elementRecord()), - RECORD_COMPONENT(JavaLanguageLocalize.elementRecord_component()), - SNIPPET_BODY(JavaLanguageLocalize.elementSnippet_body()), - STATEMENT(JavaLanguageLocalize.elementStatement()), - UNKNOWN(JavaLanguageLocalize.elementUnknown()), - VARIABLE(JavaLanguageLocalize.elementVariable()), - THROWS_LIST(JavaLanguageLocalize.elementThrowsList()), - EXTENDS_LIST(JavaLanguageLocalize.elementExtendsList()), - RECEIVER_PARAMETER(JavaLanguageLocalize.elementReceiverParameter()), - METHOD_CALL(JavaLanguageLocalize.elementMethodCall()), - TYPE_ARGUMENTS(JavaLanguageLocalize.elementTypeArguments()), - SEMICOLON(JavaLanguageLocalize.elementTypeSemicolon()); + ABSTRACT_METHOD(JavaLanguageLocalize.elementAbstractMethodNominative(), JavaLanguageLocalize.elementAbstractMethodAccusative()), + ANNOTATION(JavaLanguageLocalize.elementAnnotationNominative(), JavaLanguageLocalize.elementAnnotationAccusative()), + ANONYMOUS_CLASS(JavaLanguageLocalize.elementAnonymousClassNominative(), JavaLanguageLocalize.elementAnonymousClassAccusative()), + CLASS(JavaLanguageLocalize.elementClassNominative(), JavaLanguageLocalize.elementClassAccusative()), + TYPE_PARAMETER(JavaLanguageLocalize.elementTypeParameterNominative(), JavaLanguageLocalize.elementTypeParameterAccusative()), + CONSTANT(JavaLanguageLocalize.elementConstantNominative(), JavaLanguageLocalize.elementConstantAccusative()), + CONSTRUCTOR(JavaLanguageLocalize.elementConstructorNominative(), JavaLanguageLocalize.elementConstructorAccusative()), + ENUM(JavaLanguageLocalize.elementEnumNominative(), JavaLanguageLocalize.elementEnumAccusative()), + ENUM_CONSTANT(JavaLanguageLocalize.elementEnumConstantNominative(), JavaLanguageLocalize.elementEnumConstantAccusative()), + EXPRESSION(JavaLanguageLocalize.elementExpressionNominative(), JavaLanguageLocalize.elementExpressionAccusative()), + FIELD(JavaLanguageLocalize.elementFieldNominative(), JavaLanguageLocalize.elementFieldAccusative()), + INITIALIZER(JavaLanguageLocalize.elementInitializerNominative(), JavaLanguageLocalize.elementInitializerAccusative()), + INTERFACE(JavaLanguageLocalize.elementInterfaceNominative(), JavaLanguageLocalize.elementInterfaceAccusative()), + LABEL(JavaLanguageLocalize.elementLabelNominative(), JavaLanguageLocalize.elementLabelAccusative()), + LOCAL_VARIABLE(JavaLanguageLocalize.elementLocalVariableNominative(), JavaLanguageLocalize.elementLocalVariableAccusative()), + METHOD(JavaLanguageLocalize.elementMethodNominative(), JavaLanguageLocalize.elementMethodAccusative()), + MODULE(JavaLanguageLocalize.elementModuleNominative(), JavaLanguageLocalize.elementModuleAccusative()), + PACKAGE(JavaLanguageLocalize.elementPackageNominative(), JavaLanguageLocalize.elementPackageAccusative()), + PARAMETER(JavaLanguageLocalize.elementParameterNominative(), JavaLanguageLocalize.elementParameterAccusative()), + PATTERN_VARIABLE(JavaLanguageLocalize.elementPatternVariableNominative(), JavaLanguageLocalize.elementPatternVariableAccusative()), + RECORD(JavaLanguageLocalize.elementRecordNominative(), JavaLanguageLocalize.elementRecordAccusative()), + RECORD_COMPONENT(JavaLanguageLocalize.elementRecordComponentNominative(), JavaLanguageLocalize.elementRecordComponentAccusative()), + SNIPPET_BODY(JavaLanguageLocalize.elementSnippetBodyNominative(), JavaLanguageLocalize.elementSnippetBodyAccusative()), + STATEMENT(JavaLanguageLocalize.elementStatementNominative(), JavaLanguageLocalize.elementStatementAccusative()), + UNKNOWN(JavaLanguageLocalize.elementUnknownNominative(), JavaLanguageLocalize.elementUnknownAccusative()), + VARIABLE(JavaLanguageLocalize.elementVariableNominative(), JavaLanguageLocalize.elementVariableAccusative()), + THROWS_LIST(JavaLanguageLocalize.elementThrowsListNominative(), JavaLanguageLocalize.elementThrowsListAccusative()), + EXTENDS_LIST(JavaLanguageLocalize.elementExtendsListNominative(), JavaLanguageLocalize.elementExtendsListAccusative()), + RECEIVER_PARAMETER(JavaLanguageLocalize.elementReceiverParameterNominative(), JavaLanguageLocalize.elementReceiverParameterAccusative()), + METHOD_CALL(JavaLanguageLocalize.elementMethodCallNominative(), JavaLanguageLocalize.elementMethodCallAccusative()), + TYPE_ARGUMENTS(JavaLanguageLocalize.elementTypeArgumentsNominative(), JavaLanguageLocalize.elementTypeArgumentsAccusative()), + SEMICOLON(JavaLanguageLocalize.elementTypeSemicolonNominative(), JavaLanguageLocalize.elementTypeSemicolonAccusative()); @Nonnull - private final LocalizeValue myName; + private final LocalizeValue myNameNominative; + @Nonnull + private final LocalizeValue myNameAccusative; - JavaElementKind(@Nonnull LocalizeValue name) { - myName = name; + JavaElementKind(@Nonnull LocalizeValue nameNominative, @Nonnull LocalizeValue nameAccusative) { + myNameNominative = nameNominative; + myNameAccusative = nameAccusative; } /** * @return human-readable name of the item having the subject role in the sentence (nominative case) */ public LocalizeValue subject() { - return myName; + return myNameNominative; } /** @@ -65,7 +68,7 @@ public LocalizeValue subject() { */ @Nonnull public LocalizeValue object() { - return myName; + return myNameAccusative; } /** @@ -113,7 +116,7 @@ public static JavaElementKind fromElement(@Nonnull PsiElement element) { if (method.isConstructor()) { return CONSTRUCTOR; } - if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { + if (method.isAbstract()) { return ABSTRACT_METHOD; } return METHOD; @@ -122,7 +125,7 @@ public static JavaElementKind fromElement(@Nonnull PsiElement element) { if (field instanceof PsiEnumConstant) { return ENUM_CONSTANT; } - if (field.hasModifierProperty(PsiModifier.STATIC) && field.hasModifierProperty(PsiModifier.FINAL)) { + if (field.isStatic() && field.isFinal()) { return CONSTANT; } return FIELD; diff --git a/java-language-api/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.language.JavaLanguageLocalize.yaml b/java-language-api/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.language.JavaLanguageLocalize.yaml index f59b4a39e3..b940f6392b 100644 --- a/java-language-api/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.language.JavaLanguageLocalize.yaml +++ b/java-language-api/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.language.JavaLanguageLocalize.yaml @@ -66,71 +66,135 @@ diamond.error.cannot.infer.type.arguments: text: Cannot infer type arguments for {0} diamond.error.explicit.type.parameters.for.constructor: text: Cannot use diamonds with explicit type parameters for constructor -element.abstract_method: +element.abstract.method.accusative: text: abstract method -element.annotation: +element.abstract.method.nominative: + text: abstract method +element.annotation.accusative: + text: annotation +element.annotation.nominative: text: annotation -element.anonymous_class: +element.anonymous.class.accusative: text: anonymous class -element.class: +element.anonymous.class.nominative: + text: anonymous class +element.class.accusative: + text: class +element.class.nominative: text: class -element.constant: +element.constant.accusative: text: constant field -element.constructor: +element.constant.nominative: + text: constant field +element.constructor.accusative: + text: constructor +element.constructor.nominative: text: constructor -element.enum: +element.enum.accusative: text: enum -element.enum_constant: +element.enum.constant.accusative: text: enum constant -element.expression: +element.enum.constant.nominative: + text: enum constant +element.enum.nominative: + text: enum +element.expression.accusative: text: expression -element.extends.list: +element.expression.nominative: + text: expression +element.extends.list.accusative: + text: extends list +element.extends.list.nominative: text: extends list -element.field: +element.field.accusative: text: field -element.initializer: +element.field.nominative: + text: field +element.initializer.accusative: + text: initializer +element.initializer.nominative: text: initializer -element.interface: +element.interface.accusative: + text: interface +element.interface.nominative: text: interface element.kind.and.name: text: '{0} {1}' -element.label: +element.label.accusative: + text: label +element.label.nominative: text: label -element.local_variable: +element.local.variable.accusative: text: local variable -element.method: +element.local.variable.nominative: + text: local variable +element.method.accusative: + text: method +element.method.nominative: text: method -element.method.call: +element.method.call.accusative: text: method call -element.module: +element.method.call.nominative: + text: method call +element.module.accusative: + text: module +element.module.nominative: text: module -element.package: +element.package.accusative: text: package -element.parameter: +element.package.nominative: + text: package +element.parameter.accusative: + text: parameter +element.parameter.nominative: text: parameter -element.pattern_variable: +element.pattern.variable.accusative: text: pattern variable -element.receiver.parameter: +element.pattern.variable.nominative: + text: pattern variable +element.receiver.parameter.accusative: + text: receiver parameter +element.receiver.parameter.nominative: text: receiver parameter -element.record: +element.record.accusative: text: record -element.record_component: +element.record.nominative: + text: record +element.record.component.accusative: + text: record component +element.record.component.nominative: text: record component -element.snippet_body: +element.snippet.body.accusative: text: snippet body -element.statement: +element.snippet.body.nominative: + text: snippet body +element.statement.accusative: + text: statement +element.statement.nominative: text: statement -element.throws.list: +element.throws.list.accusative: text: throws list -element.type.arguments: +element.throws.list.nominative: + text: throws list +element.type.arguments.accusative: + text: type arguments +element.type.arguments.nominative: text: type arguments -element.type.parameter: +element.type.parameter.accusative: text: type parameter -element.type.semicolon: +element.type.parameter.nominative: + text: type parameter +element.type.semicolon.accusative: + text: semicolon +element.type.semicolon.nominative: text: semicolon -element.unknown: +element.unknown.accusative: text: element -element.variable: +element.unknown.nominative: + text: element +element.variable.accusative: + text: variable +element.variable.nominative: text: variable else.without.if: text: '''else'' without ''if'''