Replacing JavaClassNames with CommonClassNames.

java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java

@@ -30,7 +30,6 @@
 import consulo.annotation.access.RequiredReadAction;
 import consulo.codeEditor.Editor;
 import consulo.java.language.impl.localize.JavaErrorLocalize;
-import consulo.java.language.module.util.JavaClassNames;
 import consulo.language.editor.intention.IntentionAction;
 import consulo.language.editor.intention.QuickFixAction;
 import consulo.language.editor.intention.SyntheticIntentionAction;
@@ -45,7 +44,6 @@
 import consulo.project.Project;
 import consulo.util.lang.Comparing;
 import consulo.util.lang.ObjectUtil;
-
 import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
 
@@ -138,7 +136,7 @@ public static HighlightInfo checkMemberValueType(@Nullable PsiAnnotationMemberVa
             return null;
         }
 
-        if (expectedType instanceof PsiClassType && expectedType.equalsToText(JavaClassNames.JAVA_LANG_CLASS)) {
+        if (expectedType instanceof PsiClassType && expectedType.equalsToText(CommonClassNames.JAVA_LANG_CLASS)) {
             if (!(value instanceof PsiClassObjectAccessExpression)) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(value)
@@ -251,7 +249,7 @@ else if (isAnnotationRepeatedTwice(owner, annotationType.getQualifiedName())) {
             }
 
             PsiAnnotation metaAnno =
-                PsiImplUtil.findAnnotation(annotationType.getModifierList(), JavaClassNames.JAVA_LANG_ANNOTATION_REPEATABLE);
+                PsiImplUtil.findAnnotation(annotationType.getModifierList(), CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE);
             if (metaAnno == null) {
                 LocalizeValue explanation = JavaErrorLocalize.annotationNonRepeatable(annotationType.getQualifiedName());
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
@@ -303,7 +301,7 @@ private static PsiClass contained(PsiClass annotationType) {
         if (contained == null || !contained.isAnnotationType()) {
             return null;
         }
-        if (PsiImplUtil.findAnnotation(contained.getModifierList(), JavaClassNames.JAVA_LANG_ANNOTATION_REPEATABLE) == null) {
+        if (PsiImplUtil.findAnnotation(contained.getModifierList(), CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE) == null) {
             return null;
         }
 
@@ -584,8 +582,8 @@ public static HighlightInfo.Builder checkClashesWithSuperMethods(@Nonnull PsiAnn
                 PsiClass containingClass = method.getContainingClass();
                 if (containingClass != null) {
                     String qualifiedName = containingClass.getQualifiedName();
-                    if (JavaClassNames.JAVA_LANG_OBJECT.equals(qualifiedName)
-                        || JavaClassNames.JAVA_LANG_ANNOTATION_ANNOTATION.equals(qualifiedName)) {
+                    if (CommonClassNames.JAVA_LANG_OBJECT.equals(qualifiedName)
+                        || CommonClassNames.JAVA_LANG_ANNOTATION_ANNOTATION.equals(qualifiedName)) {
                         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                             .range(nameIdentifier)
                             .descriptionAndTooltip(
@@ -644,7 +642,7 @@ public static HighlightInfo.Builder checkTargetAnnotationDuplicates(PsiAnnotatio
         }
 
         if (!(nameRef.resolve() instanceof PsiClass annotationClass)
-            || !JavaClassNames.JAVA_LANG_ANNOTATION_TARGET.equals(annotationClass.getQualifiedName())) {
+            || !CommonClassNames.JAVA_LANG_ANNOTATION_TARGET.equals(annotationClass.getQualifiedName())) {
             return null;
         }
 
@@ -678,7 +676,7 @@ public static HighlightInfo.Builder checkTargetAnnotationDuplicates(PsiAnnotatio
     @RequiredReadAction
     public static HighlightInfo.Builder checkFunctionalInterface(@Nonnull PsiAnnotation annotation, @Nonnull LanguageLevel languageLevel) {
         if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)
-            && Comparing.strEqual(annotation.getQualifiedName(), JavaClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE)) {
+            && Comparing.strEqual(annotation.getQualifiedName(), CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE)) {
             PsiAnnotationOwner owner = annotation.getOwner();
             if (owner instanceof PsiModifierList modifierList
                 && modifierList.getParent() instanceof PsiClass psiClass) {
@@ -700,7 +698,7 @@ public static HighlightInfo.Builder checkFunctionalInterface(@Nonnull PsiAnnotat
     @RequiredReadAction
     public static HighlightInfo.Builder checkRepeatableAnnotation(PsiAnnotation annotation) {
         String qualifiedName = annotation.getQualifiedName();
-        if (!JavaClassNames.JAVA_LANG_ANNOTATION_REPEATABLE.equals(qualifiedName)) {
+        if (!CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE.equals(qualifiedName)) {
             return null;
         }
 
@@ -859,7 +857,7 @@ private static boolean isStatic(PsiModifierListOwner owner) {
     public static RetentionPolicy getRetentionPolicy(@Nonnull PsiClass annotation) {
         PsiModifierList modifierList = annotation.getModifierList();
         if (modifierList != null) {
-            PsiAnnotation retentionAnno = modifierList.findAnnotation(JavaClassNames.JAVA_LANG_ANNOTATION_RETENTION);
+            PsiAnnotation retentionAnno = modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION);
             if (retentionAnno == null) {
                 return RetentionPolicy.CLASS;
             }
@@ -906,15 +904,15 @@ public Boolean visitArrayType(PsiArrayType arrayType) {
         public Boolean visitClassType(PsiClassType classType) {
             if (classType.getParameters().length > 0) {
                 PsiClassType rawType = classType.rawType();
-                return rawType.equalsToText(JavaClassNames.JAVA_LANG_CLASS);
+                return rawType.equalsToText(CommonClassNames.JAVA_LANG_CLASS);
             }
 
             PsiClass aClass = classType.resolve();
             if (aClass != null && (aClass.isAnnotationType() || aClass.isEnum())) {
                 return Boolean.TRUE;
             }
 
-            return classType.equalsToText(JavaClassNames.JAVA_LANG_CLASS) || classType.equalsToText(JavaClassNames.JAVA_LANG_STRING);
+            return classType.equalsToText(CommonClassNames.JAVA_LANG_CLASS) || classType.equalsToText(CommonClassNames.JAVA_LANG_STRING);
         }
     }
 

java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationPsiFix.java

@@ -244,7 +244,7 @@ private ExternalAnnotationsManager.AnnotationPlace choosePlace(@Nonnull PsiModif
             if (AnnotationsHighlightUtil.getRetentionPolicy(aClass) == RetentionPolicy.RUNTIME) {
                 return ExternalAnnotationsManager.AnnotationPlace.IN_CODE;
             }
-            if (!JavaClassNames.DEFAULT_PACKAGE.equals(StringUtil.getPackageName(myAnnotation))) {
+            if (!CommonClassNames.DEFAULT_PACKAGE.equals(StringUtil.getPackageName(myAnnotation))) {
                 PsiClass resolvedBySimpleName = JavaPsiFacade.getInstance(project).getResolveHelper()
                     .resolveReferencedClass(StringUtil.getShortName(myAnnotation), modifierListOwner);
                 if (resolvedBySimpleName != null && resolvedBySimpleName.getManager().areElementsEquivalent(resolvedBySimpleName, aClass)) {

java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/AnonymousCanBeLambdaInspection.java

@@ -25,11 +25,13 @@
 import com.intellij.java.language.impl.psi.controlFlow.ControlFlowUtil;
 import com.intellij.java.language.psi.*;
 import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.java.language.psi.util.*;
+import com.intellij.java.language.psi.util.InheritanceUtil;
+import com.intellij.java.language.psi.util.PsiTypesUtil;
+import com.intellij.java.language.psi.util.PsiUtil;
+import com.intellij.java.language.psi.util.RedundantCastUtil;
 import consulo.annotation.component.ExtensionImpl;
 import consulo.component.util.text.UniqueNameGenerator;
 import consulo.document.util.TextRange;
-import consulo.java.language.module.util.JavaClassNames;
 import consulo.language.editor.inspection.*;
 import consulo.language.editor.inspection.localize.InspectionLocalize;
 import consulo.language.editor.intention.HighPriorityAction;
@@ -43,9 +45,9 @@
 import consulo.util.collection.ContainerUtil;
 import consulo.util.lang.Comparing;
 import consulo.util.lang.StringUtil;
+import jakarta.annotation.Nonnull;
 import org.jetbrains.annotations.Nls;
 
-import jakarta.annotation.Nonnull;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.*;
@@ -117,7 +119,7 @@ public void visitAnonymousClass(final PsiAnonymousClass aClass) {
           if (isOnTheFly && !state.reportNotAnnotatedInterfaces) {
             final PsiClass baseClass = aClass.getBaseClassType().resolve();
             LOG.assertTrue(baseClass != null);
-            if (!AnnotationUtil.isAnnotated(baseClass, JavaClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, false, false)) {
+            if (!AnnotationUtil.isAnnotated(baseClass, CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, false, false)) {
               problemHighlightType = ProblemHighlightType.INFORMATION;
             }
           }
@@ -228,7 +230,7 @@ public static boolean canBeConvertedToLambda(PsiAnonymousClass aClass,
       final PsiClassType baseClassType = aClass.getBaseClassType();
       final PsiClassType.ClassResolveResult resolveResult = baseClassType.resolveGenerics();
       final PsiClass baseClass = resolveResult.getElement();
-      if (baseClass == null || !reportNotAnnotatedInterfaces && !AnnotationUtil.isAnnotated(baseClass, JavaClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, false, false)) {
+      if (baseClass == null || !reportNotAnnotatedInterfaces && !AnnotationUtil.isAnnotated(baseClass, CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, false, false)) {
         return false;
       }
       final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(resolveResult);
@@ -470,7 +472,7 @@ private static String composeParameter(PsiParameter parameter) {
   public static boolean functionalInterfaceMethodReferenced(PsiMethod psiMethod, PsiAnonymousClass anonymClass, PsiCallExpression callExpression) {
     if (psiMethod != null && !psiMethod.hasModifierProperty(PsiModifier.STATIC)) {
       final PsiClass containingClass = psiMethod.getContainingClass();
-      if (containingClass != null && JavaClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName())) {
+      if (containingClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName())) {
         return false;
       }
 

java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inliner/AssertAllInliner.java

@@ -5,14 +5,10 @@
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.NullabilityProblemKind;
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.types.DfTypes;
 import com.intellij.java.analysis.impl.codeInspection.dataFlow.value.DfaVariableValue;
-import com.intellij.java.language.psi.JavaPsiFacade;
-import com.intellij.java.language.psi.PsiExpression;
-import com.intellij.java.language.psi.PsiMethodCallExpression;
-import com.intellij.java.language.psi.PsiType;
+import com.intellij.java.language.psi.*;
 import com.siyeh.ig.callMatcher.CallMatcher;
 import com.siyeh.ig.psiutils.MethodCallUtils;
 import com.siyeh.ig.psiutils.TypeUtils;
-import consulo.java.language.module.util.JavaClassNames;
 import jakarta.annotation.Nonnull;
 
 import static com.siyeh.ig.callMatcher.CallMatcher.anyOf;
@@ -26,7 +22,7 @@ public class AssertAllInliner implements CallInliner {
         staticCall("org.junit.jupiter.api.Assertions", "assertAll")
             .parameterTypes("org.junit.jupiter.api.function.Executable..."),
         staticCall("org.junit.jupiter.api.Assertions", "assertAll")
-            .parameterTypes(JavaClassNames.JAVA_LANG_STRING, "org.junit.jupiter.api.function.Executable...")
+            .parameterTypes(CommonClassNames.JAVA_LANG_STRING, "org.junit.jupiter.api.function.Executable...")
     );
 
 

java-analysis-impl/testsrc/com/siyeh/ig/threading/AccessToStaticFieldLockedOnInstanceInspectionTest.java

@@ -1,13 +1,13 @@
 package com.siyeh.ig.threading;
 
+import com.intellij.java.language.psi.CommonClassNames;
 import com.siyeh.ig.IGInspectionTestCase;
-import consulo.java.language.module.util.JavaClassNames;
 
 public class AccessToStaticFieldLockedOnInstanceInspectionTest extends IGInspectionTestCase {
 
   public void test() throws Exception {
     final AccessToStaticFieldLockedOnInstanceInspection tool = new AccessToStaticFieldLockedOnInstanceInspection();
-    tool.ignoredClasses.add(JavaClassNames.JAVA_UTIL_LIST);
+    tool.ignoredClasses.add(CommonClassNames.JAVA_UTIL_LIST);
     doTest("com/siyeh/igtest/threading/access_to_static_field_locked_on_instance_data", tool);
   }
 }

java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/DebuggerUtilsEx.java

@@ -64,7 +64,6 @@
 import consulo.internal.com.sun.jdi.*;
 import consulo.internal.com.sun.jdi.event.Event;
 import consulo.internal.com.sun.jdi.event.EventSet;
-import consulo.java.language.module.util.JavaClassNames;
 import consulo.language.codeStyle.CodeStyleSettingsManager;
 import consulo.language.psi.*;
 import consulo.language.psi.util.PsiTreeUtil;
@@ -154,7 +153,7 @@ public static TextRange intersectWithLine(@Nullable TextRange range, @Nullable P
     }
 
     public static boolean isAssignableFrom(@Nonnull final String baseQualifiedName, @Nonnull ReferenceType checkedType) {
-        if (JavaClassNames.JAVA_LANG_OBJECT.equals(baseQualifiedName)) {
+        if (CommonClassNames.JAVA_LANG_OBJECT.equals(baseQualifiedName)) {
             return true;
         }
         return getSuperClass(baseQualifiedName, checkedType) != null;

java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationTargetUtil.java

@@ -20,7 +20,6 @@
 import consulo.annotation.access.RequiredReadAction;
 import consulo.annotation.access.RequiredWriteAction;
 import consulo.application.dumb.IndexNotReadyException;
-import consulo.java.language.module.util.JavaClassNames;
 import consulo.language.psi.PsiCompiledElement;
 import consulo.language.psi.PsiElement;
 import consulo.language.psi.PsiReference;
@@ -263,7 +262,7 @@ public static Set<TargetType> getAnnotationTargets(@Nonnull PsiClass annotationT
         if (modifierList == null) {
             return null;
         }
-        PsiAnnotation target = modifierList.findAnnotation(JavaClassNames.JAVA_LANG_ANNOTATION_TARGET);
+        PsiAnnotation target = modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_TARGET);
         if (target == null) {
             return DEFAULT_TARGETS;  // if omitted it is applicable to all but Java 8 TYPE_USE/TYPE_PARAMETERS targets
         }

java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java

@@ -752,7 +752,7 @@ private static Map<String, PsiAnnotation> buildAnnotationMap(PsiAnnotation[] ann
     for (PsiAnnotation annotation : annotations) {
       map.put(annotation.getQualifiedName(), annotation);
     }
-    map.remove(JavaClassNames.JAVA_LANG_OVERRIDE);
+    map.remove(CommonClassNames.JAVA_LANG_OVERRIDE);
     map.remove("java.lang.SuppressWarnings");
     return map;
   }

java-language-api/src/main/java/com/intellij/java/language/psi/CommonClassNames.java

@@ -1,10 +1,25 @@
+/*
+ * Copyright 2000-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package com.intellij.java.language.psi;
 
-import consulo.annotation.DeprecationInfo;
 import consulo.java.language.module.util.JavaClassNames;
 
-@Deprecated
-@DeprecationInfo(value = "Use consulo.java.module.util.JavaClassNames", until = "2.0")
+/**
+ * @author peter
+ */
 public interface CommonClassNames extends JavaClassNames
 {
 }

java-language-api/src/main/java/consulo/java/language/module/util/JavaClassNames.java

@@ -15,9 +15,13 @@
  */
 package consulo.java.language.module.util;
 
+import consulo.annotation.DeprecationInfo;
+
 /**
  * @author peter
  */
+@Deprecated
+@DeprecationInfo(value = "Use com.intellij.java.language.psi.CommonClassNames")
 public interface JavaClassNames {
     String DEFAULT_PACKAGE = "java.lang";
     String JAVA_IO_EXTERNALIZABLE = "java.io.Externalizable";

plugin/src/main/java/com/intellij/java/impl/codeInsight/CodeInsightUtil.java

@@ -32,7 +32,6 @@
 import consulo.document.util.TextRange;
 import consulo.fileEditor.FileEditorManager;
 import consulo.java.analysis.codeInsight.JavaCodeInsightUtilCore;
-import consulo.java.language.module.util.JavaClassNames;
 import consulo.language.editor.FileModificationService;
 import consulo.language.editor.PsiEquivalenceUtil;
 import consulo.language.editor.completion.CompletionUtilCore;
@@ -269,7 +268,7 @@ public static Processor<PsiClass> createInheritorsProcessor(PsiElement context,
             arg = bound != null ? bound : ((PsiWildcardType) arg).getExtendsBound();
           }
           PsiType substitution = resolveHelper.getSubstitutionForTypeParameter(inheritorParameter, substituted, arg, true, PsiUtil.getLanguageLevel(context));
-          if (PsiType.NULL.equals(substitution) || substitution != null && substitution.equalsToText(JavaClassNames.JAVA_LANG_OBJECT) || substitution instanceof PsiWildcardType) {
+          if (PsiType.NULL.equals(substitution) || substitution != null && substitution.equalsToText(CommonClassNames.JAVA_LANG_OBJECT) || substitution instanceof PsiWildcardType) {
             continue;
           }
           if (substitution == null) {