From 2d9d598f9bc205de146483169dea2cda9c299260 Mon Sep 17 00:00:00 2001 From: UNV Date: Fri, 9 May 2025 22:03:45 +0300 Subject: [PATCH] Replacing JavaClassNames with CommonClassNames (part 8). --- .../fix/ReplaceWithObjectsEqualsFix.java | 26 +++++------ .../inference/PurityInferenceResult.java | 3 +- .../siyeh/ig/psiutils/SideEffectChecker.java | 5 +-- .../codeinsight/RuntimeTypeEvaluator.java | 3 +- .../java/impl/intelliLang/util/PsiUtilEx.java | 6 +-- .../language/psi/PsiJvmConversionHelper.java | 5 +-- .../intellij/java/language/psi/PsiType.java | 34 +++++++-------- .../java/language/psi/PsiWildcardType.java | 8 ++-- .../java/language/psi/util/PsiMethodUtil.java | 3 +- .../language/psi/util/PsiPrecedenceUtil.java | 5 +-- .../java/language/psi/util/PsiTypesUtil.java | 43 +++++++++---------- .../java/language/psi/util/PsiUtil.java | 20 ++++----- .../language/psi/util/RedundantCastUtil.java | 7 ++- .../impl/psi/impl/PsiSubstitutorImpl.java | 3 +- .../impl/psi/impl/PsiSuperMethodImplUtil.java | 5 +-- .../psi/impl/source/PsiJavaFileBaseImpl.java | 7 ++- .../source/resolve/PsiOldInferenceHelper.java | 4 +- .../tree/java/PsiLocalVariableImpl.java | 5 +-- .../tree/java/PsiSuperExpressionImpl.java | 4 +- .../impl/psi/scope/util/PsiScopesUtil.java | 4 +- ...erenceExpressionCompletionContributor.java | 21 +++++---- .../completion/SmartCastProvider.java | 6 +-- .../quickfix/RemoveUnusedVariableUtil.java | 5 +-- .../ReplaceAddAllArrayToCollectionFix.java | 3 +- .../quickfix/ReplaceWithListAccessFix.java | 4 +- .../impl/config/QuickFixFactoryImpl.java | 3 +- ...ReplaceComputeWithComputeIfPresentFix.java | 9 ++-- ...placeImplementsWithStaticImportAction.java | 3 +- ...MethodNotExposedInInterfaceInspection.java | 7 +-- ...ionForUnavailableAnnotationInspection.java | 3 +- .../impl/ig/bugs/ReplaceAllDotInspection.java | 9 ++-- .../ReturnOfCollectionFieldInspection.java | 25 ++++++----- .../ReturnOfDateFieldInspection.java | 7 ++- .../ig/fixes/SerialVersionUIDBuilder.java | 4 +- .../RedundantStringFormatCallInspection.java | 20 ++++----- .../SetReplaceableByEnumSetInspection.java | 10 ++--- .../impl/ig/psiutils/SerializationUtils.java | 16 +++---- ...meExecWithNonConstantStringInspection.java | 3 +- ...lizableClassInSecureContextInspection.java | 4 +- .../style/RedundantImplementsInspection.java | 10 ++--- ...oncatenationWithFormatStringIntention.java | 4 +- ...oncatenationWithStringBufferIntention.java | 12 +++--- .../ReplaceIfWithSwitchIntention.java | 5 +-- .../util/proximity/ReferenceListWeigher.java | 4 +- .../memberPushDown/PushDownProcessor.java | 3 +- .../SafeDeleteOverrideAnnotation.java | 10 ++--- .../usageInfo/SafeDeletePrivatizeMethod.java | 4 +- .../typeCook/deductive/builder/Result.java | 16 +++---- .../util/RefactoringHierarchyUtil.java | 7 ++- .../refactoring/util/RefactoringUtil.java | 7 ++- 50 files changed, 187 insertions(+), 257 deletions(-) diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/fix/ReplaceWithObjectsEqualsFix.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/fix/ReplaceWithObjectsEqualsFix.java index e55e6e9a26..87b008d4e1 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/fix/ReplaceWithObjectsEqualsFix.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/fix/ReplaceWithObjectsEqualsFix.java @@ -15,25 +15,18 @@ */ package com.intellij.java.analysis.impl.codeInspection.dataFlow.fix; -import jakarta.annotation.Nonnull; - -import org.jetbrains.annotations.Nls; - -import jakarta.annotation.Nullable; +import com.intellij.java.language.LanguageLevel; +import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.java.language.psi.util.PsiUtil; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; -import consulo.project.Project; -import com.intellij.java.language.LanguageLevel; -import consulo.java.language.module.util.JavaClassNames; -import com.intellij.java.language.psi.JavaPsiFacade; import consulo.language.psi.PsiElement; -import com.intellij.java.language.psi.PsiExpression; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiMethodCallExpression; -import com.intellij.java.language.psi.PsiReferenceExpression; -import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; import consulo.language.psi.util.PsiTreeUtil; -import com.intellij.java.language.psi.util.PsiUtil; +import consulo.project.Project; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; +import org.jetbrains.annotations.Nls; /** * @author peter @@ -101,7 +94,8 @@ public static ReplaceWithObjectsEqualsFix createFix(@Nonnull PsiMethodCallExpres } PsiMethod method = call.resolveMethod(); - if(method != null && method.getParameterList().getParametersCount() == 1 && method.getParameterList().getParameters()[0].getType().equalsToText(JavaClassNames.JAVA_LANG_OBJECT)) + if(method != null && method.getParameterList().getParametersCount() == 1 + && method.getParameterList().getParameters()[0].getType().equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { return new ReplaceWithObjectsEqualsFix(qualifier.getText(), noParens.getText()); } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inference/PurityInferenceResult.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inference/PurityInferenceResult.java index 57431abb0a..8d8ffb6be9 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inference/PurityInferenceResult.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inference/PurityInferenceResult.java @@ -20,7 +20,6 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; import consulo.annotation.access.RequiredReadAction; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiReference; import consulo.language.psi.scope.LocalSearchScope; @@ -87,7 +86,7 @@ else if (psiCall instanceof PsiNewExpression newExpr && psiCall.getArgumentList( if (classOrAnonymousClassReference != null && classOrAnonymousClassReference.resolve() instanceof PsiClass psiClass) { PsiClass superClass = psiClass.getSuperClass(); - return superClass == null || JavaClassNames.JAVA_LANG_OBJECT.equals(superClass.getQualifiedName()); + return superClass == null || CommonClassNames.JAVA_LANG_OBJECT.equals(superClass.getQualifiedName()); } } diff --git a/java-analysis-impl/src/main/java/com/siyeh/ig/psiutils/SideEffectChecker.java b/java-analysis-impl/src/main/java/com/siyeh/ig/psiutils/SideEffectChecker.java index dcb0832dfd..d39b59230c 100644 --- a/java-analysis-impl/src/main/java/com/siyeh/ig/psiutils/SideEffectChecker.java +++ b/java-analysis-impl/src/main/java/com/siyeh/ig/psiutils/SideEffectChecker.java @@ -22,7 +22,6 @@ import com.intellij.java.language.psi.util.PropertyUtil; import com.intellij.java.language.psi.util.PsiUtil; import consulo.annotation.access.RequiredReadAction; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.psi.PsiDirectory; import consulo.language.psi.PsiElement; @@ -347,9 +346,9 @@ private static boolean isSideEffectFreeConstructor(@Nonnull PsiNewExpression new String packageName = classPackage == null ? null : classPackage.getQualifiedName(); // all Throwable descendants from java.lang are side effects free - if (JavaClassNames.DEFAULT_PACKAGE.equals(packageName) || "java.io".equals(packageName)) { + if (CommonClassNames.DEFAULT_PACKAGE.equals(packageName) || "java.io".equals(packageName)) { PsiClass throwableClass = - JavaPsiFacade.getInstance(aClass.getProject()).findClass(JavaClassNames.JAVA_LANG_THROWABLE, aClass.getResolveScope()); + JavaPsiFacade.getInstance(aClass.getProject()).findClass(CommonClassNames.JAVA_LANG_THROWABLE, aClass.getResolveScope()); if (throwableClass != null && InheritanceUtil.isInheritorOrSelf(aClass, throwableClass, true)) { return true; } diff --git a/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/codeinsight/RuntimeTypeEvaluator.java b/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/codeinsight/RuntimeTypeEvaluator.java index 24aea0962b..3d140d3829 100644 --- a/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/codeinsight/RuntimeTypeEvaluator.java +++ b/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/codeinsight/RuntimeTypeEvaluator.java @@ -37,7 +37,6 @@ import consulo.internal.com.sun.jdi.InterfaceType; import consulo.internal.com.sun.jdi.Type; import consulo.internal.com.sun.jdi.Value; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.project.Project; import jakarta.annotation.Nonnull; @@ -109,7 +108,7 @@ public static PsiType getCastableRuntimeType(Project project, Value value) if(type instanceof ClassType) { ClassType superclass = ((ClassType) type).superclass(); - if(superclass != null && !JavaClassNames.JAVA_LANG_OBJECT.equals(superclass.name())) + if(superclass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(superclass.name())) { psiType = findPsiType(project, superclass); if(psiType != null) diff --git a/java-intellilang/src/main/java/consulo/java/impl/intelliLang/util/PsiUtilEx.java b/java-intellilang/src/main/java/consulo/java/impl/intelliLang/util/PsiUtilEx.java index cc6075d824..0fa99b329f 100644 --- a/java-intellilang/src/main/java/consulo/java/impl/intelliLang/util/PsiUtilEx.java +++ b/java-intellilang/src/main/java/consulo/java/impl/intelliLang/util/PsiUtilEx.java @@ -21,7 +21,6 @@ import consulo.application.ApplicationManager; import consulo.codeEditor.EditorFactory; import consulo.document.Document; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.psi.PsiElement; import consulo.module.content.ProjectFileIndex; @@ -29,7 +28,6 @@ import consulo.project.Project; import consulo.util.lang.Comparing; import consulo.virtualFileSystem.VirtualFile; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -93,9 +91,9 @@ public static boolean isString(@Nonnull PsiType type) { if (type instanceof PsiClassType) { // optimization. doesn't require resolve final String shortName = ((PsiClassType)type).getClassName(); - if (!Comparing.equal(shortName, JavaClassNames.JAVA_LANG_STRING_SHORT)) return false; + if (!Comparing.equal(shortName, CommonClassNames.JAVA_LANG_STRING_SHORT)) return false; } - return JavaClassNames.JAVA_LANG_STRING.equals(type.getCanonicalText()); + return CommonClassNames.JAVA_LANG_STRING.equals(type.getCanonicalText()); } public static boolean isStringOrStringArray(@Nonnull PsiType type) { diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiJvmConversionHelper.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiJvmConversionHelper.java index f18a2926cf..1fff82d610 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiJvmConversionHelper.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiJvmConversionHelper.java @@ -23,7 +23,6 @@ import com.intellij.java.language.jvm.types.JvmReferenceType; import com.intellij.java.language.jvm.types.JvmSubstitutor; import com.intellij.java.language.jvm.types.JvmType; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.logging.Logger; import consulo.logging.attachment.AttachmentFactory; @@ -91,7 +90,7 @@ static JvmReferenceType getClassSuperType(@Nonnull PsiClass psiClass) { return null; } if (psiClass.isEnum()) { - return getTypeByName(JavaClassNames.JAVA_LANG_ENUM, psiClass.getProject(), psiClass.getResolveScope()); + return getTypeByName(CommonClassNames.JAVA_LANG_ENUM, psiClass.getProject(), psiClass.getResolveScope()); } if (psiClass instanceof PsiAnonymousClass) { PsiClassType baseClassType = ((PsiAnonymousClass) psiClass).getBaseClassType(); @@ -102,7 +101,7 @@ static JvmReferenceType getClassSuperType(@Nonnull PsiClass psiClass) { return getJavaLangObject(psiClass.getManager(), psiClass.getResolveScope()); } } - if (JavaClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) { + if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) { return null; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java index 1b517d748b..9464b6fc74 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java @@ -17,12 +17,10 @@ import com.intellij.java.language.jvm.types.JvmType; import com.intellij.java.language.psi.util.TypeConversionUtil; -import consulo.project.Project; import consulo.language.psi.PsiManager; import consulo.language.psi.scope.GlobalSearchScope; -import consulo.java.language.module.util.JavaClassNames; +import consulo.project.Project; import consulo.util.collection.ArrayFactory; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -31,23 +29,23 @@ */ public abstract class PsiType implements PsiAnnotationOwner, Cloneable, JvmType { @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType BYTE = new PsiPrimitiveType("byte", JavaClassNames.JAVA_LANG_BYTE); + public static final PsiPrimitiveType BYTE = new PsiPrimitiveType("byte", CommonClassNames.JAVA_LANG_BYTE); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType CHAR = new PsiPrimitiveType("char", JavaClassNames.JAVA_LANG_CHARACTER); + public static final PsiPrimitiveType CHAR = new PsiPrimitiveType("char", CommonClassNames.JAVA_LANG_CHARACTER); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType DOUBLE = new PsiPrimitiveType("double", JavaClassNames.JAVA_LANG_DOUBLE); + public static final PsiPrimitiveType DOUBLE = new PsiPrimitiveType("double", CommonClassNames.JAVA_LANG_DOUBLE); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType FLOAT = new PsiPrimitiveType("float", JavaClassNames.JAVA_LANG_FLOAT); + public static final PsiPrimitiveType FLOAT = new PsiPrimitiveType("float", CommonClassNames.JAVA_LANG_FLOAT); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType INT = new PsiPrimitiveType("int", JavaClassNames.JAVA_LANG_INTEGER); + public static final PsiPrimitiveType INT = new PsiPrimitiveType("int", CommonClassNames.JAVA_LANG_INTEGER); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType LONG = new PsiPrimitiveType("long", JavaClassNames.JAVA_LANG_LONG); + public static final PsiPrimitiveType LONG = new PsiPrimitiveType("long", CommonClassNames.JAVA_LANG_LONG); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType SHORT = new PsiPrimitiveType("short", JavaClassNames.JAVA_LANG_SHORT); + public static final PsiPrimitiveType SHORT = new PsiPrimitiveType("short", CommonClassNames.JAVA_LANG_SHORT); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType BOOLEAN = new PsiPrimitiveType("boolean", JavaClassNames.JAVA_LANG_BOOLEAN); + public static final PsiPrimitiveType BOOLEAN = new PsiPrimitiveType("boolean", CommonClassNames.JAVA_LANG_BOOLEAN); @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType VOID = new PsiPrimitiveType("void", JavaClassNames.JAVA_LANG_VOID); + public static final PsiPrimitiveType VOID = new PsiPrimitiveType("void", CommonClassNames.JAVA_LANG_VOID); @SuppressWarnings("StaticInitializerReferencesSubClass") public static final PsiPrimitiveType NULL = new PsiPrimitiveType("null", (String) null); @@ -194,7 +192,7 @@ public static PsiClassType getTypeByName(String qName, Project project, GlobalSe */ @Nonnull public static PsiClassType getJavaLangObject(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(JavaClassNames.JAVA_LANG_OBJECT, manager.getProject(), resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_OBJECT, manager.getProject(), resolveScope); } /** @@ -206,7 +204,7 @@ public static PsiClassType getJavaLangObject(@Nonnull PsiManager manager, @Nonnu */ @Nonnull public static PsiClassType getJavaLangClass(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(JavaClassNames.JAVA_LANG_CLASS, manager.getProject(), resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_CLASS, manager.getProject(), resolveScope); } /** @@ -218,7 +216,7 @@ public static PsiClassType getJavaLangClass(@Nonnull PsiManager manager, @Nonnul */ @Nonnull public static PsiClassType getJavaLangThrowable(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(JavaClassNames.JAVA_LANG_THROWABLE, manager.getProject(), resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_THROWABLE, manager.getProject(), resolveScope); } /** @@ -230,7 +228,7 @@ public static PsiClassType getJavaLangThrowable(@Nonnull PsiManager manager, @No */ @Nonnull public static PsiClassType getJavaLangString(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(JavaClassNames.JAVA_LANG_STRING, manager.getProject(), resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_STRING, manager.getProject(), resolveScope); } /** @@ -242,7 +240,7 @@ public static PsiClassType getJavaLangString(@Nonnull PsiManager manager, @Nonnu */ @Nonnull public static PsiClassType getJavaLangError(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(JavaClassNames.JAVA_LANG_ERROR, manager.getProject(), resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_ERROR, manager.getProject(), resolveScope); } /** @@ -254,7 +252,7 @@ public static PsiClassType getJavaLangError(@Nonnull PsiManager manager, @Nonnul */ @Nonnull public static PsiClassType getJavaLangRuntimeException(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(JavaClassNames.JAVA_LANG_RUNTIME_EXCEPTION, manager.getProject(), resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, manager.getProject(), resolveScope); } /** diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiWildcardType.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiWildcardType.java index 5fa1d721c1..97bc2a3b02 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiWildcardType.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiWildcardType.java @@ -15,13 +15,11 @@ */ package com.intellij.java.language.psi; -import consulo.util.lang.Comparing; import consulo.language.psi.PsiManager; import consulo.language.psi.scope.GlobalSearchScope; -import consulo.java.language.module.util.JavaClassNames; import consulo.logging.Logger; import consulo.util.dataholder.Key; - +import consulo.util.lang.Comparing; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -163,9 +161,9 @@ public boolean equals(Object o) { PsiWildcardType that = (PsiWildcardType) o; if (myBound == null && that.myBound != null) { - return that.isExtends() && that.myBound.equalsToText(JavaClassNames.JAVA_LANG_OBJECT); + return that.isExtends() && that.myBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT); } else if (myBound != null && that.myBound == null) { - return isExtends() && myBound.equalsToText(JavaClassNames.JAVA_LANG_OBJECT); + return isExtends() && myBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT); } return myIsExtending == that.myIsExtending && Comparing.equal(myBound, that.myBound); } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiMethodUtil.java b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiMethodUtil.java index fd961997f0..97ed6f7b7f 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiMethodUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiMethodUtil.java @@ -17,7 +17,6 @@ import com.intellij.java.language.codeInsight.runner.JavaMainMethodProvider; import com.intellij.java.language.psi.*; -import consulo.java.language.module.util.JavaClassNames; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -84,7 +83,7 @@ public static boolean isMainMethod(PsiMethod method) { return false; } PsiType componentType = arrayType.getComponentType(); - return componentType.equalsToText(JavaClassNames.JAVA_LANG_STRING); + return componentType.equalsToText(CommonClassNames.JAVA_LANG_STRING); } public static boolean hasMainMethod(PsiClass psiClass) { diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiPrecedenceUtil.java b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiPrecedenceUtil.java index 03149008db..565b7bd556 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiPrecedenceUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiPrecedenceUtil.java @@ -2,7 +2,6 @@ package com.intellij.java.language.psi.util; import com.intellij.java.language.psi.*; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; @@ -69,7 +68,7 @@ public static boolean isCommutativeOperation(PsiPolyadicExpression expression) { return false; } PsiType type = expression.getType(); - return type != null && !type.equalsToText(JavaClassNames.JAVA_LANG_STRING); + return type != null && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING); } public static boolean isAssociativeOperation(PsiPolyadicExpression expression) { @@ -208,7 +207,7 @@ else if (expression instanceof PsiInstanceOfExpression) { if (!parentType.equals(childType)) { return true; } - if (childType.equalsToText(JavaClassNames.JAVA_LANG_STRING) + if (childType.equalsToText(CommonClassNames.JAVA_LANG_STRING) && !PsiTreeUtil.isAncestor(parentPolyadic.getOperands()[0], childPolyadic, true)) { PsiExpression[] operands = childPolyadic.getOperands(); for (PsiExpression operand : operands) { diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiTypesUtil.java b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiTypesUtil.java index 99d0e9ce95..3742c01ed7 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiTypesUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiTypesUtil.java @@ -18,7 +18,6 @@ import com.intellij.java.language.LanguageLevel; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.ASTNode; import consulo.language.ast.IElementType; import consulo.language.codeStyle.CodeStyleManager; @@ -46,23 +45,23 @@ public class PsiTypesUtil { private static final Map ourBoxedTypes = new HashMap<>(); static { - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_BOOLEAN, "boolean"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_BYTE, "byte"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_SHORT, "short"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_INTEGER, "int"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_LONG, "long"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_FLOAT, "float"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_DOUBLE, "double"); - ourUnboxedTypes.put(JavaClassNames.JAVA_LANG_CHARACTER, "char"); - - ourBoxedTypes.put("boolean", JavaClassNames.JAVA_LANG_BOOLEAN); - ourBoxedTypes.put("byte", JavaClassNames.JAVA_LANG_BYTE); - ourBoxedTypes.put("short", JavaClassNames.JAVA_LANG_SHORT); - ourBoxedTypes.put("int", JavaClassNames.JAVA_LANG_INTEGER); - ourBoxedTypes.put("long", JavaClassNames.JAVA_LANG_LONG); - ourBoxedTypes.put("float", JavaClassNames.JAVA_LANG_FLOAT); - ourBoxedTypes.put("double", JavaClassNames.JAVA_LANG_DOUBLE); - ourBoxedTypes.put("char", JavaClassNames.JAVA_LANG_CHARACTER); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_BOOLEAN, "boolean"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_BYTE, "byte"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_SHORT, "short"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_INTEGER, "int"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_LONG, "long"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_FLOAT, "float"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_DOUBLE, "double"); + ourUnboxedTypes.put(CommonClassNames.JAVA_LANG_CHARACTER, "char"); + + ourBoxedTypes.put("boolean", CommonClassNames.JAVA_LANG_BOOLEAN); + ourBoxedTypes.put("byte", CommonClassNames.JAVA_LANG_BYTE); + ourBoxedTypes.put("short", CommonClassNames.JAVA_LANG_SHORT); + ourBoxedTypes.put("int", CommonClassNames.JAVA_LANG_INTEGER); + ourBoxedTypes.put("long", CommonClassNames.JAVA_LANG_LONG); + ourBoxedTypes.put("float", CommonClassNames.JAVA_LANG_FLOAT); + ourBoxedTypes.put("double", CommonClassNames.JAVA_LANG_DOUBLE); + ourBoxedTypes.put("char", CommonClassNames.JAVA_LANG_CHARACTER); } @NonNls @@ -131,8 +130,8 @@ public static String getDefaultValueOfType(PsiType type, boolean customDefaultVa } if (customDefaultValues) { PsiType rawType = type instanceof PsiClassType ? ((PsiClassType) type).rawType() : null; - if (rawType != null && rawType.equalsToText(JavaClassNames.JAVA_UTIL_OPTIONAL)) { - return JavaClassNames.JAVA_UTIL_OPTIONAL + ".empty()"; + if (rawType != null && rawType.equalsToText(CommonClassNames.JAVA_UTIL_OPTIONAL)) { + return CommonClassNames.JAVA_UTIL_OPTIONAL + ".empty()"; } } return PsiKeyword.NULL; @@ -234,7 +233,7 @@ public static PsiType patchMethodGetClassReturnType(@Nonnull PsiExpression call, public static boolean isGetClass(PsiMethod method) { if (GET_CLASS_METHOD.equals(method.getName())) { PsiClass aClass = method.getContainingClass(); - return aClass != null && JavaClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedName()); + return aClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedName()); } return false; } @@ -244,7 +243,7 @@ public static PsiType createJavaLangClassType(@Nonnull PsiElement context, @Null if (qualifierType != null) { PsiUtil.ensureValidType(qualifierType); JavaPsiFacade facade = JavaPsiFacade.getInstance(context.getProject()); - PsiClass javaLangClass = facade.findClass(JavaClassNames.JAVA_LANG_CLASS, context.getResolveScope()); + PsiClass javaLangClass = facade.findClass(CommonClassNames.JAVA_LANG_CLASS, context.getResolveScope()); if (javaLangClass != null && javaLangClass.getTypeParameters().length == 1) { PsiSubstitutor substitutor = PsiSubstitutor.EMPTY. put(javaLangClass.getTypeParameters()[0], PsiWildcardType.createExtends(context.getManager(), qualifierType)); diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiUtil.java b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiUtil.java index 501c2f1247..27ca8e9a5a 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/util/PsiUtil.java @@ -29,7 +29,6 @@ import consulo.annotation.access.RequiredWriteAction; import consulo.document.util.TextRange; import consulo.java.language.module.extension.JavaModuleExtension; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.ast.TokenSet; import consulo.language.psi.*; @@ -59,8 +58,6 @@ import java.util.*; import java.util.function.Predicate; -import static consulo.java.language.module.util.JavaClassNames.JAVA_LANG_STRING; - public final class PsiUtil extends PsiUtilCore { private static final Logger LOG = Logger.getInstance(PsiUtil.class); @@ -841,9 +838,10 @@ public static boolean isCompileTimeConstant(@Nonnull PsiField field) { * JLS 15.28 */ public static boolean isCompileTimeConstant(@Nonnull PsiVariable field) { - return field.hasModifierProperty(PsiModifier.FINAL) && (TypeConversionUtil.isPrimitiveAndNotNull(field.getType()) || field.getType() - .equalsToText( - JAVA_LANG_STRING)) && field.hasInitializer() + return field.hasModifierProperty(PsiModifier.FINAL) + && (TypeConversionUtil.isPrimitiveAndNotNull(field.getType()) + || field.getType().equalsToText(CommonClassNames.JAVA_LANG_STRING)) + && field.hasInitializer() && isConstantExpression(field.getInitializer()); } @@ -1012,7 +1010,7 @@ public static PsiType captureTypeParameterBounds( for (PsiType boundType : boundTypes) { PsiType substitutedBoundType = captureSubstitutor.substitute(boundType); if (substitutedBoundType != null && !(substitutedBoundType instanceof PsiWildcardType) - && !substitutedBoundType.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)) { + && !substitutedBoundType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { if (originalBound instanceof PsiArrayType && substitutedBoundType instanceof PsiArrayType && !originalBound.isAssignableFrom(substitutedBoundType) && !substitutedBoundType.isAssignableFrom(originalBound)) { @@ -1343,8 +1341,8 @@ private static boolean hasDefaultCtrInHierarchy( @Nullable public static PsiType extractIterableTypeParameter(@Nullable PsiType psiType, boolean eraseTypeParameter) { - PsiType type = substituteTypeParameter(psiType, JavaClassNames.JAVA_LANG_ITERABLE, 0, eraseTypeParameter); - return type != null ? type : substituteTypeParameter(psiType, JavaClassNames.JAVA_UTIL_COLLECTION, 0, eraseTypeParameter); + PsiType type = substituteTypeParameter(psiType, CommonClassNames.JAVA_LANG_ITERABLE, 0, eraseTypeParameter); + return type != null ? type : substituteTypeParameter(psiType, CommonClassNames.JAVA_UTIL_COLLECTION, 0, eraseTypeParameter); } @Nullable @@ -1444,7 +1442,7 @@ public static PsiMethod[] getResourceCloserMethodsForType(@Nonnull PsiClassType Project project = resourceClass.getProject(); JavaPsiFacade facade = JavaPsiFacade.getInstance(project); PsiClass autoCloseable = - facade.findClass(JavaClassNames.JAVA_LANG_AUTO_CLOSEABLE, (GlobalSearchScope)ProjectScopes.getLibrariesScope(project)); + facade.findClass(CommonClassNames.JAVA_LANG_AUTO_CLOSEABLE, (GlobalSearchScope)ProjectScopes.getLibrariesScope(project)); if (autoCloseable == null) { return null; } @@ -1489,7 +1487,7 @@ public static PsiMethod getResourceCloserMethodForType(@Nonnull PsiClassType res Project project = resourceClass.getProject(); JavaPsiFacade facade = JavaPsiFacade.getInstance(project); PsiClass autoCloseable = - facade.findClass(JavaClassNames.JAVA_LANG_AUTO_CLOSEABLE, (GlobalSearchScope)ProjectScopes.getLibrariesScope(project)); + facade.findClass(CommonClassNames.JAVA_LANG_AUTO_CLOSEABLE, (GlobalSearchScope)ProjectScopes.getLibrariesScope(project)); if (autoCloseable == null) { return null; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/util/RedundantCastUtil.java b/java-language-api/src/main/java/com/intellij/java/language/psi/util/RedundantCastUtil.java index 0630ac99f9..acec102e61 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/util/RedundantCastUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/util/RedundantCastUtil.java @@ -17,7 +17,6 @@ import com.intellij.java.language.codeInsight.AnnotationUtil; import com.intellij.java.language.psi.*; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.psi.PsiElement; @@ -28,9 +27,9 @@ import consulo.util.collection.ArrayUtil; import consulo.util.lang.Comparing; import consulo.util.lang.ref.Ref; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.ArrayList; import java.util.HashSet; import java.util.List; @@ -554,7 +553,7 @@ public static boolean isTypeCastSemantic(PsiTypeCastExpression typeCast) { } if (operand instanceof PsiLambdaExpression || operand instanceof PsiMethodReferenceExpression) { - if (castType instanceof PsiClassType && InheritanceUtil.isInheritor(PsiUtil.resolveClassInType(castType), JavaClassNames.JAVA_IO_SERIALIZABLE)) + if (castType instanceof PsiClassType && InheritanceUtil.isInheritor(PsiUtil.resolveClassInType(castType), CommonClassNames.JAVA_IO_SERIALIZABLE)) return true; if (castType instanceof PsiIntersectionType) { boolean redundant = false; @@ -631,6 +630,6 @@ public static boolean isInPolymorphicCall(final PsiTypeCastExpression typeCast) private static boolean isPolymorphicMethod(PsiMethodCallExpression expression) { final PsiElement method = expression.getMethodExpression().resolve(); return method instanceof PsiMethod && - AnnotationUtil.isAnnotated((PsiMethod) method, JavaClassNames.JAVA_LANG_INVOKE_MH_POLYMORPHIC, false, true); + AnnotationUtil.isAnnotated((PsiMethod) method, CommonClassNames.JAVA_LANG_INVOKE_MH_POLYMORPHIC, false, true); } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSubstitutorImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSubstitutorImpl.java index d4e8961ee6..05f45fa5c1 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSubstitutorImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSubstitutorImpl.java @@ -8,7 +8,6 @@ import com.intellij.java.language.psi.util.PsiUtil; import consulo.annotation.access.RequiredReadAction; import consulo.application.util.RecursionManager; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiUtilCore; import consulo.logging.Logger; @@ -184,7 +183,7 @@ private PsiWildcardType rebound(@Nonnull PsiWildcardType type, @Nonnull PsiType LOG.assertTrue(newBound.isValid()); if (type.isExtends()) { - if (newBound.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)) { + if (newBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { return PsiWildcardType.createUnbounded(type.getManager()); } return PsiWildcardType.createExtends(type.getManager(), newBound); diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSuperMethodImplUtil.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSuperMethodImplUtil.java index 32d5dbcba2..dc9811b38b 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSuperMethodImplUtil.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiSuperMethodImplUtil.java @@ -22,7 +22,6 @@ import com.intellij.java.language.psi.util.*; import consulo.application.progress.ProgressManager; import consulo.application.util.*; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.impl.psi.LightElement; import consulo.language.psi.PsiInvalidElementAccessException; import consulo.language.psi.PsiModificationTracker; @@ -135,7 +134,7 @@ private static boolean canHaveSuperMethod(@Nonnull PsiMethod method, boolean che return false; } PsiClass parentClass = method.getContainingClass(); - return parentClass != null && !JavaClassNames.JAVA_LANG_OBJECT.equals(parentClass.getQualifiedName()); + return parentClass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(parentClass.getQualifiedName()); } @Nullable @@ -398,7 +397,7 @@ private static boolean isSuperMethod( PsiClass containingClass = method.getContainingClass(); if (!superMethod.isConstructor() && !aClass.equals(superClass) && MethodSignatureUtil.isSubsignature(superSignatureHierarchical, hierarchicalMethodSignature) && superClass != null) { - if (superClass.isInterface() || JavaClassNames.JAVA_LANG_OBJECT.equals(superClass.getQualifiedName())) { + if (superClass.isInterface() || CommonClassNames.JAVA_LANG_OBJECT.equals(superClass.getQualifiedName())) { //noinspection SimplifiableIfStatement if (superMethod.isStatic() || superMethod.hasModifierProperty(PsiModifier.DEFAULT) && method.isStatic() diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiJavaFileBaseImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiJavaFileBaseImpl.java index 493038f350..0440b230b5 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiJavaFileBaseImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiJavaFileBaseImpl.java @@ -37,7 +37,6 @@ import consulo.application.util.CachedValueProvider; import consulo.application.util.CachedValuesManager; import consulo.application.util.function.Processor; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.Language; import consulo.language.ast.ASTNode; import consulo.language.ast.IElementType; @@ -58,10 +57,10 @@ import consulo.util.dataholder.Key; import consulo.util.dataholder.NotNullLazyKey; import consulo.virtualFileSystem.VirtualFile; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; +import org.jetbrains.annotations.NonNls; + import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; @@ -71,7 +70,7 @@ public abstract class PsiJavaFileBaseImpl extends PsiFileImpl implements PsiJavaFile { private static final Logger LOG = Logger.getInstance(PsiJavaFileBaseImpl.class); @NonNls - private static final String[] IMPLICIT_IMPORTS = {JavaClassNames.DEFAULT_PACKAGE}; + private static final String[] IMPLICIT_IMPORTS = {CommonClassNames.DEFAULT_PACKAGE}; private final CachedValue> myResolveCache; private volatile String myPackageName; diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/PsiOldInferenceHelper.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/PsiOldInferenceHelper.java index 11271122b8..ab03a98248 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/PsiOldInferenceHelper.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/PsiOldInferenceHelper.java @@ -25,14 +25,12 @@ import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.application.util.RecursionGuard; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiManager; import consulo.language.psi.scope.GlobalSearchScope; import consulo.logging.Logger; import consulo.util.collection.ArrayUtil; import consulo.util.lang.Pair; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -498,7 +496,7 @@ public Pair getSubstitutionForTypeParameterConstraint(P if (arg == null || arg.getDeepComponentType() instanceof PsiPrimitiveType || arg instanceof PsiIntersectionType || - (psiClass != null && (isContraVariantPosition || !JavaClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName()) || (arg instanceof PsiArrayType)))) { + (psiClass != null && (isContraVariantPosition || !CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName()) || (arg instanceof PsiArrayType)))) { PsiType bound = intersectAllExtends(typeParam, arg); return Pair.create(bound, ConstraintType.SUPERTYPE); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiLocalVariableImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiLocalVariableImpl.java index 8960862c5a..23055cb6e2 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiLocalVariableImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiLocalVariableImpl.java @@ -25,7 +25,6 @@ import com.intellij.java.language.impl.psi.impl.source.tree.JavaSharedImplUtil; import com.intellij.java.language.psi.*; import consulo.content.scope.SearchScope; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.ASTNode; import consulo.language.ast.ChildRoleBase; import consulo.language.ast.IElementType; @@ -46,8 +45,8 @@ import consulo.logging.Logger; import consulo.navigation.ItemPresentation; import consulo.navigation.ItemPresentationProvider; - import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.HashSet; import java.util.Set; @@ -157,7 +156,7 @@ public Object computeConstantValue(Set visitedVars) { PsiType type = getType(); // javac rejects all non primitive and non String constants, although JLS states constants "variables whose initializers are constant expressions" - if (!(type instanceof PsiPrimitiveType) && !type.equalsToText(JavaClassNames.JAVA_LANG_STRING)) return null; + if (!(type instanceof PsiPrimitiveType) && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) return null; PsiExpression initializer = getInitializer(); if (initializer == null) return null; diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiSuperExpressionImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiSuperExpressionImpl.java index b8e98f4c0e..9ebf9eb6dc 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiSuperExpressionImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiSuperExpressionImpl.java @@ -19,7 +19,6 @@ import com.intellij.java.language.impl.psi.impl.source.tree.ChildRole; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.ASTNode; import consulo.language.ast.ChildRoleBase; import consulo.language.ast.IElementType; @@ -27,7 +26,6 @@ import consulo.language.psi.PsiElementVisitor; import consulo.language.psi.util.PsiTreeUtil; import consulo.logging.Logger; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -71,7 +69,7 @@ public PsiType getType() { @Nullable private PsiType getSuperType(PsiClass aClass, boolean checkImmediateSuperInterfaces) { - if (JavaClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedName())) return null; + if (CommonClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedName())) return null; final PsiClass containingClass = checkImmediateSuperInterfaces ? PsiTreeUtil.getParentOfType(this, PsiClass.class) : null; if (containingClass != null) { diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/scope/util/PsiScopesUtil.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/scope/util/PsiScopesUtil.java index 1e338b9828..823a7cebed 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/scope/util/PsiScopesUtil.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/scope/util/PsiScopesUtil.java @@ -29,7 +29,6 @@ import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.annotation.access.RequiredReadAction; import consulo.application.progress.ProgressIndicatorProvider; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiInvalidElementAccessException; import consulo.language.psi.PsiManager; @@ -39,7 +38,6 @@ import consulo.language.util.IncorrectOperationException; import consulo.logging.Logger; import consulo.util.lang.Comparing; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -535,7 +533,7 @@ else if (resolve instanceof PsiClass psiClass) { } else if (superExpr.getQualifier() != null && PsiUtil.isLanguageLevel8OrHigher(qualifier) - && JavaClassNames.JAVA_LANG_CLONEABLE.equals(psiClass.getQualifiedName()) + && CommonClassNames.JAVA_LANG_CLONEABLE.equals(psiClass.getQualifiedName()) && psiClass.isInterface()) { processor.setAccessClass(psiClass); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/ReferenceExpressionCompletionContributor.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/ReferenceExpressionCompletionContributor.java index 5f7b951f64..2cd34d8acb 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/ReferenceExpressionCompletionContributor.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/ReferenceExpressionCompletionContributor.java @@ -29,7 +29,6 @@ import consulo.application.AllIcons; import consulo.application.util.matcher.PrefixMatcher; import consulo.externalService.statistic.FeatureUsageTracker; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.codeStyle.CodeStyleSettingsManager; import consulo.language.editor.completion.CompletionUtilCore; import consulo.language.editor.completion.lookup.InsertionContext; @@ -65,9 +64,12 @@ */ public class ReferenceExpressionCompletionContributor { private static final Logger LOG = Logger.getInstance(ReferenceExpressionCompletionContributor.class); - private static final PsiMethodPattern OBJECT_METHOD_PATTERN = psiMethod().withName(StandardPatterns.string().oneOf("hashCode", "equals", "finalize", "wait", "notify", "notifyAll", "getClass", - "clone", "toString")). - definedInClass(JavaClassNames.JAVA_LANG_OBJECT); + private static final PsiMethodPattern OBJECT_METHOD_PATTERN = psiMethod() + .withName( + StandardPatterns.string() + .oneOf("hashCode", "equals", "finalize", "wait", "notify", "notifyAll", "getClass", "clone", "toString") + ) + .definedInClass(CommonClassNames.JAVA_LANG_OBJECT); private static final PrefixMatcher TRUE_MATCHER = new PrefixMatcher("") { @Override public boolean prefixMatches(@Nonnull String name) { @@ -278,7 +280,7 @@ private static void addSecondCompletionVariants(PsiElement element, PsiReference final PsiElement qualifier = element1 instanceof PsiJavaCodeReferenceElement ? ((PsiJavaCodeReferenceElement) element1).getQualifier() : null; final PsiType expectedType = parameters.getExpectedType(); if (!OBJECT_METHOD_PATTERN.accepts(object) || allowGetClass(object, parameters)) { - if (parameters.getParameters().getInvocationCount() >= 3 || !itemType.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (parameters.getParameters().getInvocationCount() >= 3 || !itemType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { if (!(object instanceof PsiMethod && ((PsiMethod) object).getParameterList().getParametersCount() > 0)) { addChainedCallVariants(element, baseItem, result, itemType, expectedType, parameters); } @@ -370,7 +372,7 @@ public void handleInsert(InsertionContext context) { context.getDocument().replaceString(startOffset, context.getTailOffset(), newText); context.commitDocument(); - JavaCodeStyleManager.getInstance(project).shortenClassReferences(context.getFile(), startOffset, startOffset + JavaClassNames.JAVA_UTIL_ARRAYS.length()); + JavaCodeStyleManager.getInstance(project).shortenClassReferences(context.getFile(), startOffset, startOffset + CommonClassNames.JAVA_UTIL_ARRAYS.length()); } }); } @@ -398,7 +400,7 @@ private static String getArraysConversionMethod(PsiType itemType, PsiType expect } private static PsiType getStreamComponentType(PsiType expectedType) { - return PsiUtil.substituteTypeParameter(expectedType, JavaClassNames.JAVA_UTIL_STREAM_BASE_STREAM, 0, true); + return PsiUtil.substituteTypeParameter(expectedType, CommonClassNames.JAVA_UTIL_STREAM_BASE_STREAM, 0, true); } private static void addToArrayConversions(final PsiElement element, @@ -515,7 +517,7 @@ private static boolean shouldChain(PsiElement element, PsiType qualifierType, Ps if (object instanceof PsiMethod) { final PsiMethod method = (PsiMethod) object; - if (psiMethod().withName("toArray").withParameterCount(1).definedInClass(JavaClassNames.JAVA_UTIL_COLLECTION).accepts(method)) { + if (psiMethod().withName("toArray").withParameterCount(1).definedInClass(CommonClassNames.JAVA_UTIL_COLLECTION).accepts(method)) { return false; } final PsiMethod parentMethod = PsiTreeUtil.getParentOfType(element, PsiMethod.class); @@ -551,7 +553,8 @@ private static boolean isUselessObjectMethod(PsiMethod method, PsiMethod parentM } if ("toString".equals(method.getName())) { - if (qualifierType.equalsToText(JavaClassNames.JAVA_LANG_STRING_BUFFER) || InheritanceUtil.isInheritor(qualifierType, JavaClassNames.JAVA_LANG_ABSTRACT_STRING_BUILDER)) { + if (qualifierType.equalsToText(CommonClassNames.JAVA_LANG_STRING_BUFFER) + || InheritanceUtil.isInheritor(qualifierType, CommonClassNames.JAVA_LANG_ABSTRACT_STRING_BUILDER)) { return false; } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/SmartCastProvider.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/SmartCastProvider.java index a398e9340c..08c0de9266 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/SmartCastProvider.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/SmartCastProvider.java @@ -17,7 +17,6 @@ import consulo.codeEditor.ScrollType; import consulo.document.Document; import consulo.externalService.statistic.FeatureUsageTracker; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.codeStyle.CommonCodeStyleSettings; import consulo.language.codeStyle.PostprocessReformattingAspect; import consulo.language.editor.completion.*; @@ -32,7 +31,6 @@ import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.ProcessingContext; import consulo.util.collection.ContainerUtil; - import jakarta.annotation.Nonnull; import java.util.Collections; @@ -152,7 +150,7 @@ static List getParenthesizedCastExpectationByOperandType(PsiEl } PsiType type = operand.getType(); - return type == null || type.equalsToText(JavaClassNames.JAVA_LANG_OBJECT) + return type == null || type.equalsToText(CommonClassNames.JAVA_LANG_OBJECT) ? Collections.emptyList() : Collections.singletonList(new ExpectedTypeInfoImpl( type, @@ -178,7 +176,7 @@ private static void addHierarchyTypes( infoClass, true, superClass -> { - if (!JavaClassNames.JAVA_LANG_OBJECT.equals(superClass.getQualifiedName())) { + if (!CommonClassNames.JAVA_LANG_OBJECT.equals(superClass.getQualifiedName())) { result.accept(JavaPsiFacade.getElementFactory(superClass.getProject()) .createType(CompletionUtilCore.getOriginalOrSelf(superClass))); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedVariableUtil.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedVariableUtil.java index 481939716a..5cc9bd5662 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedVariableUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/RemoveUnusedVariableUtil.java @@ -19,14 +19,13 @@ import com.intellij.java.language.psi.util.InheritanceUtil; import com.intellij.java.language.psi.util.PropertyUtil; import com.intellij.java.language.psi.util.PsiUtil; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiDirectory; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.PsiPackage; import consulo.language.util.IncorrectOperationException; - import jakarta.annotation.Nonnull; + import java.util.*; public class RemoveUnusedVariableUtil { @@ -76,7 +75,7 @@ static boolean isSideEffectFreeConstructor(PsiNewExpression newExpression) { // all Throwable descendants from java.lang are side effects free if ("java.lang".equals(packageName) || "java.io".equals(packageName)) { - PsiClass throwableClass = JavaPsiFacade.getInstance(aClass.getProject()).findClass(JavaClassNames.JAVA_LANG_THROWABLE, aClass.getResolveScope()); + PsiClass throwableClass = JavaPsiFacade.getInstance(aClass.getProject()).findClass(CommonClassNames.JAVA_LANG_THROWABLE, aClass.getResolveScope()); if (throwableClass != null && InheritanceUtil.isInheritorOrSelf(aClass, throwableClass, true)) { return true; } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceAddAllArrayToCollectionFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceAddAllArrayToCollectionFix.java index e44d87ba86..501946d6e7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceAddAllArrayToCollectionFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceAddAllArrayToCollectionFix.java @@ -28,7 +28,6 @@ import consulo.content.bundle.Sdk; import consulo.java.language.bundle.JavaSdkTypeUtil; import consulo.java.language.module.extension.JavaModuleExtension; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.FileModificationService; import consulo.language.editor.intention.SyntheticIntentionAction; import consulo.language.psi.PsiElement; @@ -69,7 +68,7 @@ public boolean isAvailable(@Nonnull final Project project, final Editor editor, if (element instanceof PsiMethod) { final PsiMethod method = (PsiMethod)element; final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiClass collectionsClass = psiFacade.findClass(JavaClassNames.JAVA_UTIL_COLLECTION, GlobalSearchScope.allScope(project)); + final PsiClass collectionsClass = psiFacade.findClass(CommonClassNames.JAVA_UTIL_COLLECTION, GlobalSearchScope.allScope(project)); if (collectionsClass != null && InheritanceUtil.isInheritorOrSelf(method.getContainingClass(), collectionsClass, true)) { if (Comparing.strEqual(method.getName(), "addAll") && PsiType.BOOLEAN.equals(method.getReturnType())) { final PsiParameter[] psiParameters = method.getParameterList().getParameters(); diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceWithListAccessFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceWithListAccessFix.java index eb3a806d74..12c75d5a3e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceWithListAccessFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ReplaceWithListAccessFix.java @@ -19,7 +19,6 @@ import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.codeEditor.Editor; import consulo.java.analysis.impl.JavaQuickFixBundle; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.FileModificationService; import consulo.language.editor.intention.SyntheticIntentionAction; @@ -27,7 +26,6 @@ import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; import consulo.project.Project; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -74,7 +72,7 @@ public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file @Nullable private PsiType createUtilListType(@Nonnull Project project) { final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiClass listClass = JavaPsiFacade.getInstance(project).findClass(JavaClassNames.JAVA_UTIL_LIST, myArrayAccessExpression.getResolveScope()); + final PsiClass listClass = JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_UTIL_LIST, myArrayAccessExpression.getResolveScope()); if (listClass == null) return null; diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java index 5c9f2a2ec8..62c204f012 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java @@ -42,7 +42,6 @@ import consulo.document.util.TextRange; import consulo.ide.impl.idea.codeInsight.daemon.impl.quickfix.RenameElementFix; import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.editor.AutoImportHelper; import consulo.language.editor.CodeInsightSettings; @@ -948,7 +947,7 @@ public IntentionAction createNotIterableForEachLoopFix(@Nonnull PsiExpression ex final PsiElement parent = expression.getParent(); if (parent instanceof PsiForeachStatement) { final PsiType type = expression.getType(); - if (InheritanceUtil.isInheritor(type, JavaClassNames.JAVA_UTIL_ITERATOR)) { + if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_ITERATOR)) { return new ReplaceIteratorForEachLoopWithIteratorForLoopFix((PsiForeachStatement)parent); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceComputeWithComputeIfPresentFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceComputeWithComputeIfPresentFix.java index 3dfe2a30c8..d7e2d7c75f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceComputeWithComputeIfPresentFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/ReplaceComputeWithComputeIfPresentFix.java @@ -6,22 +6,21 @@ import com.siyeh.ig.psiutils.ExpressionUtils; import consulo.annotation.access.RequiredReadAction; import consulo.java.analysis.impl.codeInsight.JavaInspectionsBundle; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.inspection.LocalQuickFix; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.editor.intention.HighPriorityAction; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; import consulo.project.Project; -import org.jetbrains.annotations.Contract; - import jakarta.annotation.Nonnull; +import org.jetbrains.annotations.Contract; import static consulo.util.lang.ObjectUtil.tryCast; public class ReplaceComputeWithComputeIfPresentFix implements LocalQuickFix, HighPriorityAction { - private static final CallMatcher MAP_COMPUTE = CallMatcher.instanceCall(JavaClassNames.JAVA_UTIL_MAP, "compute"). - parameterTypes("K", JavaClassNames.JAVA_UTIL_FUNCTION_BI_FUNCTION); + private static final CallMatcher MAP_COMPUTE = + CallMatcher.instanceCall(CommonClassNames.JAVA_UTIL_MAP, "compute") + .parameterTypes("K", CommonClassNames.JAVA_UTIL_FUNCTION_BI_FUNCTION); @Override @Nonnull diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInspection/actions/ReplaceImplementsWithStaticImportAction.java b/plugin/src/main/java/com/intellij/java/impl/codeInspection/actions/ReplaceImplementsWithStaticImportAction.java index b52bc19a4e..19f5d71898 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInspection/actions/ReplaceImplementsWithStaticImportAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInspection/actions/ReplaceImplementsWithStaticImportAction.java @@ -27,7 +27,6 @@ import consulo.application.Result; import consulo.application.progress.ProgressManager; import consulo.codeEditor.Editor; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.FileModificationService; import consulo.language.editor.TargetElementUtil; import consulo.language.editor.WriteCommandAction; @@ -93,7 +92,7 @@ private static boolean isEmptyClass(Project project, PsiClass targetClass) { if (extendsList != null && extendsList.getReferencedTypes().length > 0) { final List methods = new ArrayList(Arrays.asList(targetClass.getAllMethods())); final PsiClass objectClass = - JavaPsiFacade.getInstance(project).findClass(JavaClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(project)); + JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(project)); if (objectClass == null) return false; methods.removeAll(Arrays.asList(objectClass.getMethods())); if (methods.size() > 0) return false; diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/PublicMethodNotExposedInInterfaceInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/PublicMethodNotExposedInInterfaceInspection.java index fb9eeb8cdd..6e5b857530 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/PublicMethodNotExposedInInterfaceInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/abstraction/PublicMethodNotExposedInInterfaceInspection.java @@ -19,10 +19,7 @@ import com.intellij.java.impl.ig.fixes.AddToIgnoreIfAnnotatedByListQuickFix; import com.intellij.java.impl.ig.psiutils.LibraryUtil; import com.intellij.java.language.codeInsight.AnnotationUtil; -import com.intellij.java.language.psi.PsiClass; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiModifier; -import com.intellij.java.language.psi.PsiModifierListOwner; +import com.intellij.java.language.psi.*; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; @@ -166,7 +163,7 @@ private boolean exposedInInterface(PsiMethod method) { return true; } final String superclassName = superClass.getQualifiedName(); - if (JavaClassNames.JAVA_LANG_OBJECT.equals(superclassName)) { + if (CommonClassNames.JAVA_LANG_OBJECT.equals(superclassName)) { return true; } if (exposedInInterface(superMethod)) { diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReflectionForUnavailableAnnotationInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReflectionForUnavailableAnnotationInspection.java index 0b81f4f824..262ae8552a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReflectionForUnavailableAnnotationInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReflectionForUnavailableAnnotationInspection.java @@ -21,7 +21,6 @@ import com.siyeh.ig.psiutils.TypeUtils; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @@ -88,7 +87,7 @@ public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expressio if (modifierList == null) { return; } - final PsiAnnotation retentionAnnotation = modifierList.findAnnotation(JavaClassNames.JAVA_LANG_ANNOTATION_RETENTION); + final PsiAnnotation retentionAnnotation = modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION); if (retentionAnnotation == null) { registerError(arg); return; diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReplaceAllDotInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReplaceAllDotInspection.java index e6b8670b05..df0292bff4 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReplaceAllDotInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ReplaceAllDotInspection.java @@ -22,7 +22,6 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @@ -74,12 +73,10 @@ public void visitMethodCallExpression( return; } final String canonicalText = argumentType.getCanonicalText(); - if (!JavaClassNames.JAVA_LANG_STRING.equals(canonicalText)) { + if (!CommonClassNames.JAVA_LANG_STRING.equals(canonicalText)) { return; } - final String argValue = - (String)ConstantExpressionUtil.computeCastTo(argument, - argumentType); + final String argValue = (String)ConstantExpressionUtil.computeCastTo(argument, argumentType); if (!".".equals(argValue)) { return; } @@ -92,7 +89,7 @@ public void visitMethodCallExpression( return; } final String qualifiedName = containingClass.getQualifiedName(); - if (!JavaClassNames.JAVA_LANG_STRING.equals(qualifiedName)) { + if (!CommonClassNames.JAVA_LANG_STRING.equals(qualifiedName)) { return; } registerMethodCallError(expression); diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfCollectionFieldInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfCollectionFieldInspection.java index 785c93151e..d4e2fdcdc7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfCollectionFieldInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfCollectionFieldInspection.java @@ -27,7 +27,6 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; @@ -82,23 +81,23 @@ public String buildErrorString(Object... infos) { protected InspectionGadgetsFix buildFix(Object... infos) { final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)infos[1]; final String text = referenceExpression.getText(); - if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_MAP)) { - if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_SORTED_MAP)) { - return new ReturnOfCollectionFieldFix(JavaClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableSortedMap(" + text + ')', JavaClassNames.JAVA_UTIL_SORTED_MAP); + if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_MAP)) { + if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_SORTED_MAP)) { + return new ReturnOfCollectionFieldFix(CommonClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableSortedMap(" + text + ')', CommonClassNames.JAVA_UTIL_SORTED_MAP); } - return new ReturnOfCollectionFieldFix(JavaClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableMap(" + text + ')', JavaClassNames.JAVA_UTIL_MAP); + return new ReturnOfCollectionFieldFix(CommonClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableMap(" + text + ')', CommonClassNames.JAVA_UTIL_MAP); } - else if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_COLLECTION)) { - if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_SET)) { - if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_SORTED_SET)) { - return new ReturnOfCollectionFieldFix(JavaClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableSortedSet(" + text + ')', JavaClassNames.JAVA_UTIL_SORTED_SET); + else if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_COLLECTION)) { + if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_SET)) { + if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_SORTED_SET)) { + return new ReturnOfCollectionFieldFix(CommonClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableSortedSet(" + text + ')', CommonClassNames.JAVA_UTIL_SORTED_SET); } - return new ReturnOfCollectionFieldFix(JavaClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableSet(" + text + ')', JavaClassNames.JAVA_UTIL_SET); + return new ReturnOfCollectionFieldFix(CommonClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableSet(" + text + ')', CommonClassNames.JAVA_UTIL_SET); } - else if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_LIST)) { - return new ReturnOfCollectionFieldFix(JavaClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableList(" + text + ')', JavaClassNames.JAVA_UTIL_LIST); + else if (TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_LIST)) { + return new ReturnOfCollectionFieldFix(CommonClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableList(" + text + ')', CommonClassNames.JAVA_UTIL_LIST); } - return new ReturnOfCollectionFieldFix(JavaClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableCollection(" + text + ')', JavaClassNames.JAVA_UTIL_COLLECTION); + return new ReturnOfCollectionFieldFix(CommonClassNames.JAVA_UTIL_COLLECTIONS + ".unmodifiableCollection(" + text + ')', CommonClassNames.JAVA_UTIL_COLLECTION); } return null; } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfDateFieldInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfDateFieldInspection.java index 5f6f49ef12..4f6207d496 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfDateFieldInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/encapsulation/ReturnOfDateFieldInspection.java @@ -23,7 +23,6 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; @@ -88,7 +87,7 @@ protected void doFix(Project project, ProblemDescriptor descriptor) throws Incor } final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)element; final String type = - TypeUtils.expressionHasTypeOrSubtype(referenceExpression, JavaClassNames.JAVA_UTIL_DATE, JavaClassNames.JAVA_UTIL_CALENDAR); + TypeUtils.expressionHasTypeOrSubtype(referenceExpression, CommonClassNames.JAVA_UTIL_DATE, CommonClassNames.JAVA_UTIL_CALENDAR); if (type == null) { return; } @@ -119,8 +118,8 @@ public void visitReturnStatement(@Nonnull PsiReturnStatement statement) { if (!(element instanceof PsiField)) { return; } - final String type = TypeUtils.expressionHasTypeOrSubtype( - returnValue, JavaClassNames.JAVA_UTIL_DATE, JavaClassNames.JAVA_UTIL_CALENDAR); + final String type = + TypeUtils.expressionHasTypeOrSubtype(returnValue, CommonClassNames.JAVA_UTIL_DATE, CommonClassNames.JAVA_UTIL_CALENDAR); if (type == null) { return; } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/fixes/SerialVersionUIDBuilder.java b/plugin/src/main/java/com/intellij/java/impl/ig/fixes/SerialVersionUIDBuilder.java index e462bc98ef..2437993cf9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/fixes/SerialVersionUIDBuilder.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/fixes/SerialVersionUIDBuilder.java @@ -20,7 +20,6 @@ import com.intellij.java.language.psi.util.PsiUtil; import com.siyeh.ig.psiutils.ClassUtils; import com.siyeh.ig.psiutils.TypeUtils; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiManager; @@ -158,8 +157,7 @@ public static long computeDefaultSUID(PsiClass psiClass) { final Project project = psiClass.getProject(); final GlobalSearchScope scope = GlobalSearchScope.allScope(project); final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiClass serializable = - psiFacade.findClass(JavaClassNames.JAVA_IO_SERIALIZABLE, scope); + final PsiClass serializable = psiFacade.findClass(CommonClassNames.JAVA_IO_SERIALIZABLE, scope); if (serializable == null) { // no jdk defined for project. return -1L; diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/performance/RedundantStringFormatCallInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/performance/RedundantStringFormatCallInspection.java index 7ccc8dbcbf..776206ca6c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/performance/RedundantStringFormatCallInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/performance/RedundantStringFormatCallInspection.java @@ -16,18 +16,16 @@ package com.intellij.java.impl.ig.performance; import com.intellij.java.language.psi.*; +import com.siyeh.ig.BaseInspection; +import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.language.psi.*; -import consulo.project.Project; -import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.ast.IElementType; +import consulo.language.editor.inspection.ProblemDescriptor; +import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.InspectionGadgetsFix; -import com.siyeh.InspectionGadgetsBundle; -import consulo.java.language.module.util.JavaClassNames; +import consulo.project.Project; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NonNls; @@ -107,7 +105,7 @@ public void visitMethodCallExpression(PsiMethodCallExpression expression) { return; } final String className = aClass.getQualifiedName(); - if (!JavaClassNames.JAVA_LANG_STRING.equals(className)) { + if (!CommonClassNames.JAVA_LANG_STRING.equals(className)) { return; } final PsiExpression firstArgument = arguments[0]; @@ -115,7 +113,7 @@ public void visitMethodCallExpression(PsiMethodCallExpression expression) { if (firstType == null || containsPercentN(firstArgument)) { return; } - if (firstType.equalsToText(JavaClassNames.JAVA_LANG_STRING) && arguments.length == 1) { + if (firstType.equalsToText(CommonClassNames.JAVA_LANG_STRING) && arguments.length == 1) { registerMethodCallError(expression); } else if (firstType.equalsToText("java.util.Locale")) { @@ -127,7 +125,7 @@ else if (firstType.equalsToText("java.util.Locale")) { if (secondType == null) { return; } - if (secondType.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (secondType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { registerMethodCallError(expression); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/performance/SetReplaceableByEnumSetInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/performance/SetReplaceableByEnumSetInspection.java index 681820b460..adc59a4bda 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/performance/SetReplaceableByEnumSetInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/performance/SetReplaceableByEnumSetInspection.java @@ -15,16 +15,12 @@ */ package com.intellij.java.impl.ig.performance; -import com.intellij.java.language.psi.PsiClass; -import com.intellij.java.language.psi.PsiClassType; -import com.intellij.java.language.psi.PsiNewExpression; -import com.intellij.java.language.psi.PsiType; +import com.intellij.java.language.psi.*; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.psiutils.TypeUtils; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import jakarta.annotation.Nonnull; @ExtensionImpl @@ -62,8 +58,8 @@ public void visitNewExpression(@Nonnull PsiNewExpression expression) { if (!(argumentType instanceof PsiClassType argumentClassType)) { return; } - if (!TypeUtils.expressionHasTypeOrSubtype(expression, JavaClassNames.JAVA_UTIL_SET) - || TypeUtils.expressionHasTypeOrSubtype(expression, JavaClassNames.JAVA_UTIL_ENUM_SET)) { + if (!TypeUtils.expressionHasTypeOrSubtype(expression, CommonClassNames.JAVA_UTIL_SET) + || TypeUtils.expressionHasTypeOrSubtype(expression, CommonClassNames.JAVA_UTIL_ENUM_SET)) { return; } PsiClass argumentClass = argumentClassType.resolve(); diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/psiutils/SerializationUtils.java b/plugin/src/main/java/com/intellij/java/impl/ig/psiutils/SerializationUtils.java index 2db19fec4e..691b656975 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/psiutils/SerializationUtils.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/psiutils/SerializationUtils.java @@ -19,8 +19,6 @@ import com.intellij.java.language.psi.util.InheritanceUtil; import com.siyeh.ig.psiutils.MethodUtils; import com.siyeh.ig.psiutils.TypeUtils; -import consulo.java.language.module.util.JavaClassNames; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -30,11 +28,11 @@ private SerializationUtils() { } public static boolean isSerializable(@Nullable PsiClass aClass) { - return InheritanceUtil.isInheritor(aClass, JavaClassNames.JAVA_IO_SERIALIZABLE); + return InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_IO_SERIALIZABLE); } public static boolean isExternalizable(@Nullable PsiClass aClass) { - return InheritanceUtil.isInheritor(aClass, JavaClassNames.JAVA_IO_EXTERNALIZABLE); + return InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_IO_EXTERNALIZABLE); } public static boolean isDirectlySerializable(@Nonnull PsiClass aClass) { @@ -49,7 +47,7 @@ public static boolean isDirectlySerializable(@Nonnull PsiClass aClass) { continue; } final String name = implemented.getQualifiedName(); - if (JavaClassNames.JAVA_IO_SERIALIZABLE.equals(name)) { + if (CommonClassNames.JAVA_IO_SERIALIZABLE.equals(name)) { return true; } } @@ -107,11 +105,11 @@ public static boolean isWriteObject(@Nonnull PsiMethod method) { } public static boolean isReadResolve(@Nonnull PsiMethod method) { - return MethodUtils.simpleMethodMatches(method, null, JavaClassNames.JAVA_LANG_OBJECT, "readResolve"); + return MethodUtils.simpleMethodMatches(method, null, CommonClassNames.JAVA_LANG_OBJECT, "readResolve"); } public static boolean isWriteReplace(@Nonnull PsiMethod method) { - return MethodUtils.simpleMethodMatches(method, null, JavaClassNames.JAVA_LANG_OBJECT, "writeReplace"); + return MethodUtils.simpleMethodMatches(method, null, CommonClassNames.JAVA_LANG_OBJECT, "writeReplace"); } public static boolean isProbablySerializable(PsiType type) { @@ -135,8 +133,8 @@ public static boolean isProbablySerializable(PsiType type) { if (isExternalizable(psiClass)) { return true; } - if (InheritanceUtil.isInheritor(psiClass, JavaClassNames.JAVA_UTIL_COLLECTION) || - InheritanceUtil.isInheritor(psiClass, JavaClassNames.JAVA_UTIL_MAP)) { + if (InheritanceUtil.isInheritor(psiClass, CommonClassNames.JAVA_UTIL_COLLECTION) || + InheritanceUtil.isInheritor(psiClass, CommonClassNames.JAVA_UTIL_MAP)) { final PsiType[] parameters = classTYpe.getParameters(); for (PsiType parameter : parameters) { if (!isProbablySerializable(parameter)) { diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/security/RuntimeExecWithNonConstantStringInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/security/RuntimeExecWithNonConstantStringInspection.java index 07f7d2bade..19115b56d6 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/security/RuntimeExecWithNonConstantStringInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/security/RuntimeExecWithNonConstantStringInspection.java @@ -21,7 +21,6 @@ import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @@ -80,7 +79,7 @@ public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expressio } final PsiExpression argument = arguments[0]; final PsiType type = argument.getType(); - if (type == null || !type.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (type == null || !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { return; } if (PsiUtil.isConstantExpression(argument)) { diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/security/SerializableClassInSecureContextInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/security/SerializableClassInSecureContextInspection.java index 1bf7ae7f2c..3b5f3ab086 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/security/SerializableClassInSecureContextInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/security/SerializableClassInSecureContextInspection.java @@ -16,6 +16,7 @@ package com.intellij.java.impl.ig.security; import com.intellij.java.impl.ig.psiutils.SerializationUtils; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiMethod; import com.intellij.java.language.psi.PsiTypeParameter; @@ -26,7 +27,6 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; -import consulo.java.language.module.util.JavaClassNames; import consulo.localize.LocalizeValue; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -85,7 +85,7 @@ public void visitClass(@Nonnull PsiClass aClass) { break; } } - if (ignoreThrowable && InheritanceUtil.isInheritor(aClass, false, JavaClassNames.JAVA_LANG_THROWABLE)) { + if (ignoreThrowable && InheritanceUtil.isInheritor(aClass, false, CommonClassNames.JAVA_LANG_THROWABLE)) { return; } registerClassError(aClass); diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java index 934530752b..5ddacd305f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/style/RedundantImplementsInspection.java @@ -15,6 +15,7 @@ */ package com.intellij.java.impl.ig.style; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiJavaCodeReferenceElement; import com.intellij.java.language.psi.PsiReferenceList; @@ -24,7 +25,6 @@ import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.MultipleCheckboxOptionsPanel; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; @@ -154,14 +154,10 @@ private void checkImplementedClass( PsiJavaCodeReferenceElement[] extendsElements, PsiJavaCodeReferenceElement[] implementsElements) { final String qualifiedName = implementedClass.getQualifiedName(); - if (ignoreSerializable && - JavaClassNames.JAVA_IO_SERIALIZABLE.equals( - qualifiedName)) { + if (ignoreSerializable && CommonClassNames.JAVA_IO_SERIALIZABLE.equals(qualifiedName)) { return; } - else if (ignoreCloneable && - JavaClassNames.JAVA_LANG_CLONEABLE.equals( - qualifiedName)) { + else if (ignoreCloneable && CommonClassNames.JAVA_LANG_CLONEABLE.equals(qualifiedName)) { return; } for (final PsiJavaCodeReferenceElement extendsElement : diff --git a/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithFormatStringIntention.java b/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithFormatStringIntention.java index 9d8565fd9a..01c08f36b6 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithFormatStringIntention.java +++ b/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithFormatStringIntention.java @@ -98,8 +98,8 @@ else if ("print".equals(name)) { return false; } final String qualifiedName = containingClass.getQualifiedName(); - if (!JavaClassNames.JAVA_IO_PRINT_STREAM.equals(qualifiedName) && - !JavaClassNames.JAVA_IO_PRINT_WRITER.equals(qualifiedName)) { + if (!CommonClassNames.JAVA_IO_PRINT_STREAM.equals(qualifiedName) + && !CommonClassNames.JAVA_IO_PRINT_WRITER.equals(qualifiedName)) { return false; } final StringBuilder newExpression = new StringBuilder(); diff --git a/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithStringBufferIntention.java b/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithStringBufferIntention.java index d6b49f6dc6..447da1d916 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithStringBufferIntention.java +++ b/plugin/src/main/java/com/intellij/java/impl/ipp/concatenation/ReplaceConcatenationWithStringBufferIntention.java @@ -23,13 +23,11 @@ import com.siyeh.IntentionPowerPackBundle; import com.siyeh.ig.psiutils.ParenthesesUtils; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.intention.IntentionMetaData; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; +import org.jetbrains.annotations.NonNls; @ExtensionImpl @IntentionMetaData(ignoreId = "java.ReplaceConcatenationWithStringBufferIntention", fileExtensions = "java", categories = {"Java", "Strings"}) @@ -103,7 +101,7 @@ private static boolean isPartOfStringBufferAppend(PsiExpression expression) { return false; } final String className = type.getCanonicalText(); - if (!JavaClassNames.JAVA_LANG_STRING_BUFFER.equals(className) && !JavaClassNames.JAVA_LANG_STRING_BUILDER.equals(className)) { + if (!CommonClassNames.JAVA_LANG_STRING_BUFFER.equals(className) && !CommonClassNames.JAVA_LANG_STRING_BUILDER.equals(className)) { return false; } @NonNls final String methodName = methodExpression.getReferenceName(); @@ -114,13 +112,13 @@ private static void turnExpressionIntoChainedAppends(PsiExpression expression, @ if (expression instanceof PsiPolyadicExpression) { final PsiPolyadicExpression concatenation = (PsiPolyadicExpression)expression; final PsiType type = concatenation.getType(); - if (type != null && !type.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (type != null && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { result.append(".append(").append(concatenation.getText()).append(')'); return; } final PsiExpression[] operands = concatenation.getOperands(); final PsiType startType = operands[0].getType(); - if (startType == null || startType.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (startType == null || startType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { for (PsiExpression operand : operands) { turnExpressionIntoChainedAppends(operand, result); } @@ -132,7 +130,7 @@ private static void turnExpressionIntoChainedAppends(PsiExpression expression, @ final PsiExpression operand = operands[i]; if (!string) { final PsiType operandType = operand.getType(); - if (operandType == null || operandType.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (operandType == null || operandType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { final PsiElementFactory factory = JavaPsiFacade.getElementFactory(expression.getProject()); final PsiExpression newExpression = factory.createExpressionFromText(newExpressionText.toString(), expression); turnExpressionIntoChainedAppends(newExpression, result); diff --git a/plugin/src/main/java/com/intellij/java/impl/ipp/switchtoif/ReplaceIfWithSwitchIntention.java b/plugin/src/main/java/com/intellij/java/impl/ipp/switchtoif/ReplaceIfWithSwitchIntention.java index 9a62bc28f7..1498427a49 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ipp/switchtoif/ReplaceIfWithSwitchIntention.java +++ b/plugin/src/main/java/com/intellij/java/impl/ipp/switchtoif/ReplaceIfWithSwitchIntention.java @@ -21,7 +21,6 @@ import com.intellij.java.language.psi.*; import com.siyeh.ig.psiutils.ControlFlowUtils; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.editor.intention.IntentionMetaData; import consulo.language.psi.PsiComment; @@ -29,9 +28,9 @@ import consulo.language.psi.PsiWhiteSpace; import consulo.language.psi.util.PsiTreeUtil; import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; import org.jetbrains.annotations.NonNls; -import jakarta.annotation.Nullable; import java.util.ArrayList; import java.util.List; @@ -104,7 +103,7 @@ public void processIntention(@Nonnull PsiElement element) { @NonNls final StringBuilder switchStatementText = new StringBuilder(); switchStatementText.append("switch(").append(switchExpression.getText()).append("){"); final PsiType type = switchExpression.getType(); - final boolean castToInt = type != null && type.equalsToText(JavaClassNames.JAVA_LANG_INTEGER); + final boolean castToInt = type != null && type.equalsToText(CommonClassNames.JAVA_LANG_INTEGER); for (IfStatementBranch branch : branches) { boolean hasConflicts = false; for (IfStatementBranch testBranch : branches) { diff --git a/plugin/src/main/java/com/intellij/java/impl/psi/util/proximity/ReferenceListWeigher.java b/plugin/src/main/java/com/intellij/java/impl/psi/util/proximity/ReferenceListWeigher.java index b4088a8be1..1c3d905980 100644 --- a/plugin/src/main/java/com/intellij/java/impl/psi/util/proximity/ReferenceListWeigher.java +++ b/plugin/src/main/java/com/intellij/java/impl/psi/util/proximity/ReferenceListWeigher.java @@ -15,12 +15,12 @@ */ package com.intellij.java.impl.psi.util.proximity; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiJavaCodeReferenceElement; import com.intellij.java.language.psi.PsiReferenceList; import com.intellij.java.language.psi.util.InheritanceUtil; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.pattern.ElementPattern; import consulo.language.pattern.PlatformPatterns; import consulo.language.psi.PsiElement; @@ -113,7 +113,7 @@ public ReferenceListApplicability getApplicability(@Nonnull PsiClass aClass, @No return applicableByKind; } if (condition == Preference.Exceptions) { - return InheritanceUtil.isInheritor(aClass, JavaClassNames.JAVA_LANG_THROWABLE) ? applicableByKind : inapplicable; + return InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_LANG_THROWABLE) ? applicableByKind : inapplicable; } return unknown; } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/memberPushDown/PushDownProcessor.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/memberPushDown/PushDownProcessor.java index a851cd8f4c..034426bf2e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/memberPushDown/PushDownProcessor.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/memberPushDown/PushDownProcessor.java @@ -33,7 +33,6 @@ import consulo.annotation.access.RequiredReadAction; import consulo.application.progress.ProgressManager; import consulo.ide.impl.idea.refactoring.util.DocCommentPolicy; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.refactoring.BaseRefactoringProcessor; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.psi.PsiElement; @@ -411,7 +410,7 @@ else if (memberInfo.isToAbstract()) { } } else { //abstract method: remove @Override - final PsiAnnotation annotation = AnnotationUtil.findAnnotation(methodBySignature, JavaClassNames.JAVA_LANG_OVERRIDE); + final PsiAnnotation annotation = AnnotationUtil.findAnnotation(methodBySignature, CommonClassNames.JAVA_LANG_OVERRIDE); if (annotation != null && !leaveOverrideAnnotation(substitutor, method)) { annotation.delete(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeleteOverrideAnnotation.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeleteOverrideAnnotation.java index 9501e7b08d..4fe1f4a8df 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeleteOverrideAnnotation.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeleteOverrideAnnotation.java @@ -16,17 +16,17 @@ package com.intellij.java.impl.refactoring.safeDelete.usageInfo; import com.intellij.java.language.codeInsight.AnnotationUtil; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiAnnotation; import com.intellij.java.language.psi.PsiMethod; -import consulo.language.psi.PsiElement; import consulo.language.editor.refactoring.safeDelete.usageInfo.SafeDeleteCustomUsageInfo; import consulo.language.editor.refactoring.safeDelete.usageInfo.SafeDeleteUsageInfo; +import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; -import consulo.java.language.module.util.JavaClassNames; /** - * User: anna - * Date: 7/22/13 + * @author anna + * @since 2013-07-22 */ public class SafeDeleteOverrideAnnotation extends SafeDeleteUsageInfo implements SafeDeleteCustomUsageInfo { public SafeDeleteOverrideAnnotation(PsiElement element, PsiElement referencedElement) { @@ -38,7 +38,7 @@ public PsiMethod getMethod() { } public void performRefactoring() throws IncorrectOperationException { - final PsiAnnotation annotation = AnnotationUtil.findAnnotation(getMethod(), true, JavaClassNames.JAVA_LANG_OVERRIDE); + final PsiAnnotation annotation = AnnotationUtil.findAnnotation(getMethod(), true, CommonClassNames.JAVA_LANG_OVERRIDE); if (annotation != null) { annotation.delete(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeletePrivatizeMethod.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeletePrivatizeMethod.java index 6c0066ed1b..83ab9824d8 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeletePrivatizeMethod.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/safeDelete/usageInfo/SafeDeletePrivatizeMethod.java @@ -16,6 +16,7 @@ package com.intellij.java.impl.refactoring.safeDelete.usageInfo; import com.intellij.java.language.codeInsight.AnnotationUtil; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiAnnotation; import com.intellij.java.language.psi.PsiMethod; import com.intellij.java.language.psi.PsiModifier; @@ -23,7 +24,6 @@ import consulo.language.editor.refactoring.safeDelete.usageInfo.SafeDeleteCustomUsageInfo; import consulo.language.editor.refactoring.safeDelete.usageInfo.SafeDeleteUsageInfo; import consulo.language.util.IncorrectOperationException; -import consulo.java.language.module.util.JavaClassNames; /** * @author dsl @@ -40,7 +40,7 @@ public PsiMethod getMethod() { @Override public void performRefactoring() throws IncorrectOperationException { PsiUtil.setModifierProperty(getMethod(), PsiModifier.PRIVATE, true); - final PsiAnnotation annotation = AnnotationUtil.findAnnotation(getMethod(), true, JavaClassNames.JAVA_LANG_OVERRIDE); + final PsiAnnotation annotation = AnnotationUtil.findAnnotation(getMethod(), true, CommonClassNames.JAVA_LANG_OVERRIDE); if (annotation != null) { annotation.delete(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/typeCook/deductive/builder/Result.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/typeCook/deductive/builder/Result.java index 6368314ff4..c99d13a81c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/typeCook/deductive/builder/Result.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/typeCook/deductive/builder/Result.java @@ -15,20 +15,18 @@ */ package com.intellij.java.impl.refactoring.typeCook.deductive.builder; +import com.intellij.java.impl.refactoring.typeCook.Settings; +import com.intellij.java.impl.refactoring.typeCook.Util; +import com.intellij.java.impl.refactoring.typeCook.deductive.resolver.Binding; import com.intellij.java.language.impl.psi.Bottom; import com.intellij.java.language.impl.psi.PsiTypeVariable; import com.intellij.java.language.psi.*; -import consulo.language.editor.refactoring.localize.RefactoringLocalize; -import consulo.logging.Logger; -import consulo.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; import consulo.language.editor.refactoring.RefactoringBundle; -import com.intellij.java.impl.refactoring.typeCook.Settings; -import com.intellij.java.impl.refactoring.typeCook.Util; -import com.intellij.java.impl.refactoring.typeCook.deductive.resolver.Binding; +import consulo.language.editor.refactoring.localize.RefactoringLocalize; +import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; -import consulo.java.language.module.util.JavaClassNames; -import org.jetbrains.annotations.NonNls; +import consulo.logging.Logger; import java.util.HashMap; import java.util.HashSet; @@ -74,7 +72,7 @@ public PsiType getCookedType(final PsiElement element) { if (myBinding != null) { final PsiType type = myBinding.substitute(myTypes.get(element)); - @NonNls final String objectFQName = JavaClassNames.JAVA_LANG_OBJECT; + final String objectFQName = CommonClassNames.JAVA_LANG_OBJECT; if (originalType.getCanonicalText().equals(objectFQName)) { if (type == null) { return originalType; diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringHierarchyUtil.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringHierarchyUtil.java index fcc54c63ee..192d26a6e9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringHierarchyUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringHierarchyUtil.java @@ -27,16 +27,15 @@ import com.intellij.java.indexing.search.searches.ClassInheritorsSearch; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.InheritanceUtil; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiManager; import consulo.language.psi.resolve.PsiElementProcessor; import consulo.language.psi.resolve.PsiElementProcessorAdapter; import consulo.logging.Logger; import consulo.util.lang.Comparing; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.*; public class RefactoringHierarchyUtil { @@ -90,7 +89,7 @@ public static PsiClass getNearestBaseClass(PsiClass subClass, boolean includeNon if (superTypes.length > 0) { PsiClass resolved = superTypes[0].resolve(); // if we have no superclass but have interfaces, prefer interfaces to class (IDEADEV-20104) - if (resolved != null && JavaClassNames.JAVA_LANG_OBJECT.equals(resolved.getQualifiedName()) && superTypes.length > 1) { + if (resolved != null && CommonClassNames.JAVA_LANG_OBJECT.equals(resolved.getQualifiedName()) && superTypes.length > 1) { resolved = superTypes[1].resolve(); } if (resolved != null) { @@ -118,7 +117,7 @@ public static ArrayList createBasesList(PsiClass subClass, boolean inc if (!subClass.isInterface()) { final PsiManager manager = subClass.getManager(); - PsiClass javaLangObject = JavaPsiFacade.getInstance(manager.getProject()).findClass(JavaClassNames.JAVA_LANG_OBJECT, subClass.getResolveScope()); + PsiClass javaLangObject = JavaPsiFacade.getInstance(manager.getProject()).findClass(CommonClassNames.JAVA_LANG_OBJECT, subClass.getResolveScope()); if (includeNonProject && javaLangObject != null && !manager.areElementsEquivalent(javaLangObject, subClass)) { bases.add(javaLangObject); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringUtil.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringUtil.java index b6a6465359..111244b1bb 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringUtil.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/util/RefactoringUtil.java @@ -43,7 +43,6 @@ import consulo.document.RangeMarker; import consulo.document.util.TextRange; import consulo.ide.impl.idea.openapi.vfs.VfsUtil; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.highlight.HighlightManager; @@ -62,8 +61,8 @@ import consulo.virtualFileSystem.VirtualFile; import consulo.virtualFileSystem.util.VirtualFileUtil; import jakarta.annotation.Nonnull; - import jakarta.annotation.Nullable; + import java.util.*; public class RefactoringUtil { @@ -463,7 +462,7 @@ public static PsiType getTypeByExpressionWithExpectedType(PsiExpression expr) { ExpectedTypeInfo[] expectedTypes = ExpectedTypesProvider.getInstance(expr.getProject()).getExpectedTypes(expr, false); if (expectedTypes.length == 1) { type = expectedTypes[0].getType(); - if (!type.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)) { + if (!type.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { return type; } } @@ -503,7 +502,7 @@ private static PsiType getTypeByExpression(PsiExpression expr, final PsiElementF if (infos.length == 1) { type = infos[0].getType(); } else { - type = factory.createTypeByFQClassName(JavaClassNames.JAVA_LANG_OBJECT, expr.getResolveScope()); + type = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, expr.getResolveScope()); } }