From 80383aa8749dff84a3ced52990e8d948cb32b274 Mon Sep 17 00:00:00 2001 From: UNV Date: Fri, 9 May 2025 15:16:24 +0300 Subject: [PATCH] Deprecating JavaClassNames in favor of original CommonClassNames. Replacing JavaClassNames with CommonClassNames. --- .../analysis/AnnotationsHighlightUtil.java | 24 +++--- .../intention/AddAnnotationPsiFix.java | 2 +- .../AnonymousCanBeLambdaInspection.java | 14 ++-- .../dataFlow/inliner/AssertAllInliner.java | 8 +- ...icFieldLockedOnInstanceInspectionTest.java | 4 +- .../java/debugger/impl/DebuggerUtilsEx.java | 3 +- .../codeInsight/AnnotationTargetUtil.java | 3 +- .../language/codeInsight/AnnotationUtil.java | 2 +- .../java/language/psi/CommonClassNames.java | 21 ++++- .../language/module/util/JavaClassNames.java | 4 + .../impl/codeInsight/CodeInsightUtil.java | 3 +- .../codeInsight/ExpectedTypesProvider.java | 30 +++---- .../FunctionalInterfaceSuggester.java | 9 +-- .../AbstractExpectedTypeSkipper.java | 5 +- .../impl/AddOverrideAnnotationAction.java | 11 ++- ...entToDateFieldFromParameterInspection.java | 5 +- ...ArchaicSystemPropertyAccessInspection.java | 22 +++-- ...ctClassExtendsConcreteClassInspection.java | 4 +- ...thodOverridesAbstractMethodInspection.java | 2 +- ...thodOverridesConcreteMethodInspection.java | 4 +- ...lsBetweenInconvertibleTypesInspection.java | 3 +- ...AssertEqualsMayBeAssertSameInspection.java | 3 +- ...AsListWithZeroOrOneArgumentInspection.java | 3 +- ...SafeStaticFieldFromInstanceInspection.java | 3 +- .../adapter/AdapterToListenerIntention.java | 2 +- .../AnonymousToInnerDialog.java | 3 +- .../AnonymousToInnerHandler.java | 9 +-- .../daemon/GenericsHighlightingTest.java | 4 +- .../codeInsight/daemon/ImportHelperTest.java | 35 ++++---- .../intellij/psi/ClsRepositoryUseTest.java | 70 +++++++--------- .../com/intellij/psi/CodeFragmentsTest.java | 4 +- .../com/intellij/psi/ConstantValuesTest.java | 2 +- .../intellij/psi/Src15RepositoryUseTest.java | 12 +-- .../intellij/psi/SrcRepositoryUseTest.java | 81 +++++++++---------- .../java_/com/intellij/psi/TypesTest.java | 25 +++--- .../tree/java/ExtendsBoundListTest.java | 11 ++- .../tree/java/ShortenClassReferencesTest.java | 17 ++-- .../psi/resolve/ResolveClassTest.java | 13 ++- .../psi/resolve/ResolveMethod15Test.java | 18 ++--- .../psi/resolve/ResolveMethodTest.java | 13 +-- .../psi/resolve/TypeInferenceTest.java | 19 +++-- .../intellij/psi/util/PropertyUtilTest.java | 26 +++--- .../ChangeSignaturePropagationTest.java | 40 ++++----- .../refactoring/ChangeSignatureTest.java | 33 ++++---- .../intellij/refactoring/CopyClassTest.java | 28 +++---- .../refactoring/IntroduceConstantTest.java | 25 +++--- .../IntroduceParameterObjectTest.java | 27 +++---- .../refactoring/IntroduceVariableTest.java | 68 ++++++++-------- .../refactoring/TurnRefsToSuperTest.java | 10 +-- .../ChangeClassSignatureTest.java | 25 +++--- .../refactoring/migration/MigrationTest.java | 8 +- 51 files changed, 375 insertions(+), 445 deletions(-) diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java index a1811ef8a0..d748edd14a 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java +++ b/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,7 +904,7 @@ 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(); @@ -914,7 +912,7 @@ public Boolean visitClassType(PsiClassType classType) { 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); } } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationPsiFix.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationPsiFix.java index babbd83381..f10cdef9f9 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/intention/AddAnnotationPsiFix.java +++ b/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)) { diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/AnonymousCanBeLambdaInspection.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/AnonymousCanBeLambdaInspection.java index c3eeeb88c7..4e26bd402f 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/AnonymousCanBeLambdaInspection.java +++ b/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; } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inliner/AssertAllInliner.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inliner/AssertAllInliner.java index 5b59ff4bcc..5836445e2b 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInspection/dataFlow/inliner/AssertAllInliner.java +++ b/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...") ); diff --git a/java-analysis-impl/testsrc/com/siyeh/ig/threading/AccessToStaticFieldLockedOnInstanceInspectionTest.java b/java-analysis-impl/testsrc/com/siyeh/ig/threading/AccessToStaticFieldLockedOnInstanceInspectionTest.java index 5af36b1deb..336e59c3be 100644 --- a/java-analysis-impl/testsrc/com/siyeh/ig/threading/AccessToStaticFieldLockedOnInstanceInspectionTest.java +++ b/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); } } \ No newline at end of file diff --git a/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/DebuggerUtilsEx.java b/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/DebuggerUtilsEx.java index 86e69dbecf..38bb6577c3 100644 --- a/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/DebuggerUtilsEx.java +++ b/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; diff --git a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationTargetUtil.java b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationTargetUtil.java index 3de0ae4390..3a1904408c 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationTargetUtil.java +++ b/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 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 } diff --git a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java index 08734bbbf4..3c91ec1441 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java +++ b/java-language-api/src/main/java/com/intellij/java/language/codeInsight/AnnotationUtil.java @@ -752,7 +752,7 @@ private static Map 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; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/CommonClassNames.java b/java-language-api/src/main/java/com/intellij/java/language/psi/CommonClassNames.java index fa3d2245cf..e8f74cefd9 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/CommonClassNames.java +++ b/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 { } diff --git a/java-language-api/src/main/java/consulo/java/language/module/util/JavaClassNames.java b/java-language-api/src/main/java/consulo/java/language/module/util/JavaClassNames.java index 6dbe05ceb4..bae4511d8d 100644 --- a/java-language-api/src/main/java/consulo/java/language/module/util/JavaClassNames.java +++ b/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"; diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/CodeInsightUtil.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/CodeInsightUtil.java index f6199d0456..3c3851b360 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/CodeInsightUtil.java +++ b/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 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) { diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/ExpectedTypesProvider.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/ExpectedTypesProvider.java index e05c9af143..aa3a92406b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/ExpectedTypesProvider.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/ExpectedTypesProvider.java @@ -37,7 +37,6 @@ import consulo.ide.ServiceManager; import consulo.ide.impl.idea.openapi.util.NullableComputable; import consulo.ide.impl.idea.util.NullableFunction; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.editor.completion.lookup.CommaTailType; import consulo.language.editor.completion.lookup.TailType; @@ -49,14 +48,16 @@ import consulo.util.collection.ArrayUtil; import consulo.util.collection.ContainerUtil; import consulo.util.collection.Stack; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; import jakarta.inject.Singleton; import org.jetbrains.annotations.NonNls; -import jakarta.annotation.Nonnull; -import jakarta.annotation.Nullable; import java.util.*; import java.util.function.Supplier; +; + /** * @author ven */ @@ -551,7 +552,7 @@ public void visitSwitchStatement(@Nonnull PsiSwitchStatement statement) { PsiManager manager = statement.getManager(); PsiClassType enumType = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory() - .createTypeByFQClassName(JavaClassNames.JAVA_LANG_ENUM, statement.getResolveScope()); + .createTypeByFQClassName(CommonClassNames.JAVA_LANG_ENUM, statement.getResolveScope()); myResult.add(createInfoImpl(enumType, enumType)); } @@ -573,7 +574,7 @@ public void visitSwitchLabelStatement(@Nonnull final PsiSwitchLabelStatement sta @Override public void visitSynchronizedStatement(@Nonnull PsiSynchronizedStatement statement) { PsiElementFactory factory = JavaPsiFacade.getInstance(statement.getProject()).getElementFactory(); - PsiType objectType = factory.createTypeByFQClassName(JavaClassNames.JAVA_LANG_OBJECT, + PsiType objectType = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, myExpr.getResolveScope()); myResult.add(createInfoImpl(objectType, objectType)); } @@ -755,7 +756,7 @@ public String compute() { } } else if (i == JavaTokenType.PLUS) { - if (anotherType == null || anotherType.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (anotherType == null || anotherType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { PsiClassType objectType = PsiType.getJavaLangObject(expr.getManager(), expr.getResolveScope()); myResult.add(createInfoImpl(objectType, anotherType != null ? anotherType : objectType)); } @@ -988,7 +989,7 @@ public void visitThrowStatement(@Nonnull PsiThrowStatement statement) { if (statement.getException() == myExpr) { PsiManager manager = statement.getManager(); PsiType throwableType = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory() - .createTypeByFQClassName(JavaClassNames.JAVA_LANG_THROWABLE, myExpr.getResolveScope()); + .createTypeByFQClassName(CommonClassNames.JAVA_LANG_THROWABLE, myExpr.getResolveScope()); PsiElement container = PsiTreeUtil.getParentOfType(statement, PsiMethod.class, PsiLambdaExpression.class, PsiClass.class); PsiType[] throwsTypes = PsiType.EMPTY_ARRAY; @@ -1004,7 +1005,7 @@ else if (container instanceof PsiLambdaExpression) { if (throwsTypes.length == 0) { final PsiClassType exceptionType = JavaPsiFacade.getInstance(manager.getProject()) - .getElementFactory().createTypeByFQClassName(JavaClassNames.JAVA_LANG_EXCEPTION, + .getElementFactory().createTypeByFQClassName(CommonClassNames.JAVA_LANG_EXCEPTION, myExpr.getResolveScope()); throwsTypes = new PsiClassType[]{exceptionType}; } @@ -1236,7 +1237,7 @@ private static PsiType getDefaultType(@Nonnull final PsiMethod method, @NonNls final String name = method.getName(); if ("contains".equals(name) || "remove".equals(name)) { - final PsiType type = checkMethod(method, JavaClassNames.JAVA_UTIL_COLLECTION, + final PsiType type = checkMethod(method, CommonClassNames.JAVA_UTIL_COLLECTION, new NullableFunction() { @Override public PsiType apply(@Nonnull final PsiClass psiClass) { @@ -1249,7 +1250,7 @@ public PsiType apply(@Nonnull final PsiClass psiClass) { } if ("containsKey".equals(name) || "remove".equals(name) || "get".equals(name) || "containsValue".equals (name)) { - final PsiType type = checkMethod(method, JavaClassNames.JAVA_UTIL_MAP, + final PsiType type = checkMethod(method, CommonClassNames.JAVA_UTIL_MAP, new NullableFunction() { @Override public PsiType apply(@Nonnull final PsiClass psiClass) { @@ -1264,7 +1265,7 @@ public PsiType apply(@Nonnull final PsiClass psiClass) { final PsiElementFactory factory = JavaPsiFacade.getElementFactory(containingClass.getProject()); if ("equals".equals(name)) { - final PsiType type = checkMethod(method, JavaClassNames.JAVA_LANG_OBJECT, + final PsiType type = checkMethod(method, CommonClassNames.JAVA_LANG_OBJECT, new NullableFunction() { @Override public PsiType apply(final PsiClass psiClass) { @@ -1292,7 +1293,7 @@ public PsiType apply(final PsiClass psiClass) { if ("assertEquals".equals(name) || "assertSame".equals(name) && method.getParameterList() .getParametersCount() == argCount) { if (argCount == 2 || argCount == 3 && method.getParameterList().getParameters()[0].getType() - .equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + .equalsToText(CommonClassNames.JAVA_LANG_STRING)) { int other = index == argCount - 1 ? index - 1 : index + 1; if (args.length > other) { ExpectedTypeInfo info = getEqualsType(args[other]); @@ -1304,10 +1305,9 @@ public PsiType apply(final PsiClass psiClass) { } if ("Logger".equals(containingClass.getName()) || "Log".equals(containingClass.getName())) { if (parameterType instanceof PsiClassType) { - PsiType typeArg = PsiUtil.substituteTypeParameter(parameterType, JavaClassNames.JAVA_LANG_CLASS, + PsiType typeArg = PsiUtil.substituteTypeParameter(parameterType, CommonClassNames.JAVA_LANG_CLASS, 0, true); - if (typeArg != null && TypeConversionUtil.erasure(typeArg).equalsToText(JavaClassNames - .JAVA_LANG_OBJECT)) { + if (typeArg != null && TypeConversionUtil.erasure(typeArg).equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { PsiClass placeClass = PsiTreeUtil.getContextOfType(argument, PsiClass.class); PsiClass classClass = ((PsiClassType)parameterType).resolve(); if (placeClass != null && classClass != null) { diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/FunctionalInterfaceSuggester.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/FunctionalInterfaceSuggester.java index e1b10ce827..752b35c0b0 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/FunctionalInterfaceSuggester.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/FunctionalInterfaceSuggester.java @@ -22,7 +22,6 @@ import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.annotation.access.RequiredReadAction; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.util.PsiTreeUtil; @@ -36,9 +35,9 @@ public class FunctionalInterfaceSuggester { public static final String[] FUNCTIONAL_INTERFACES = { //old jdk without annotations - JavaClassNames.JAVA_LANG_RUNNABLE, - JavaClassNames.JAVA_UTIL_CONCURRENT_CALLABLE, - JavaClassNames.JAVA_UTIL_COMPARATOR, + CommonClassNames.JAVA_LANG_RUNNABLE, + CommonClassNames.JAVA_UTIL_CONCURRENT_CALLABLE, + CommonClassNames.JAVA_UTIL_COMPARATOR, //IDEA "com.intellij.util.Function", @@ -172,7 +171,7 @@ private static Collection suggestFunct }; JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); GlobalSearchScope allScope = GlobalSearchScope.allScope(project); - PsiClass functionalInterfaceClass = psiFacade.findClass(JavaClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, allScope); + PsiClass functionalInterfaceClass = psiFacade.findClass(CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE, allScope); if (functionalInterfaceClass != null) { AnnotatedMembersSearch.search(functionalInterfaceClass, element.getResolveScope()).forEach(consumer); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/AbstractExpectedTypeSkipper.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/AbstractExpectedTypeSkipper.java index 1e14fd1c6f..5f3ff2297c 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/AbstractExpectedTypeSkipper.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/completion/AbstractExpectedTypeSkipper.java @@ -20,7 +20,6 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.completion.CompletionLocation; import consulo.language.editor.completion.CompletionPreselectSkipper; import consulo.language.editor.completion.CompletionStatistician; @@ -93,8 +92,8 @@ private static Result getSkippingStatus(final LookupElement item, final Completi if (toImplement > 0) return Result.ACCEPT; if (psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) return Result.ABSTRACT; - if (!isDefaultType && JavaClassNames.JAVA_LANG_STRING.equals(psiClass.getQualifiedName())) return Result.STRING; - if (JavaClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return Result.NON_DEFAULT; + if (!isDefaultType && CommonClassNames.JAVA_LANG_STRING.equals(psiClass.getQualifiedName())) return Result.STRING; + if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return Result.NON_DEFAULT; return Result.ACCEPT; } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/AddOverrideAnnotationAction.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/AddOverrideAnnotationAction.java index b88a33c2d5..58349b2a72 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/AddOverrideAnnotationAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/AddOverrideAnnotationAction.java @@ -16,15 +16,14 @@ package com.intellij.java.impl.codeInsight.intention.impl; import com.intellij.java.analysis.impl.codeInsight.intention.AddAnnotationFix; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiCodeBlock; import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiModifier; import com.intellij.java.language.psi.util.PsiUtil; import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.codeEditor.Editor; import consulo.document.util.TextRange; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.intention.IntentionAction; import consulo.language.editor.intention.IntentionMetaData; import consulo.language.editor.localize.CodeInsightLocalize; @@ -54,11 +53,11 @@ public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file if (!file.getManager().isInProject(file)) return false; PsiMethod method = findMethod(file, editor.getCaretModel().getOffset()); if (method == null) return false; - if (method.getModifierList().findAnnotation(JavaClassNames.JAVA_LANG_OVERRIDE) != null) return false; + if (method.getModifierList().findAnnotation(CommonClassNames.JAVA_LANG_OVERRIDE) != null) return false; PsiMethod[] superMethods = method.findSuperMethods(); for (PsiMethod superMethod : superMethods) { - if (!superMethod.hasModifierProperty(PsiModifier.ABSTRACT) - && new AddAnnotationFix(JavaClassNames.JAVA_LANG_OVERRIDE, method).isAvailable(project, editor, file)) { + if (!superMethod.isAbstract() + && new AddAnnotationFix(CommonClassNames.JAVA_LANG_OVERRIDE, method).isAvailable(project, editor, file)) { return true; } } @@ -71,7 +70,7 @@ && new AddAnnotationFix(JavaClassNames.JAVA_LANG_OVERRIDE, method).isAvailable(p public void invoke(@Nonnull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { PsiMethod method = findMethod(file, editor.getCaretModel().getOffset()); if (method != null) { - new AddAnnotationFix(JavaClassNames.JAVA_LANG_OVERRIDE, method).invoke(project, editor, file); + new AddAnnotationFix(CommonClassNames.JAVA_LANG_OVERRIDE, method).invoke(project, editor, file); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentToDateFieldFromParameterInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentToDateFieldFromParameterInspection.java index 5a4c102308..7894fb3d99 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentToDateFieldFromParameterInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/assignment/AssignmentToDateFieldFromParameterInspection.java @@ -23,7 +23,6 @@ import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.deadCodeNotWorking.impl.SingleCheckboxOptionsPanel; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiReference; @@ -84,9 +83,7 @@ public void visitAssignmentExpression( if (!(lhs instanceof PsiReferenceExpression)) { return; } - final String type = TypeUtils.expressionHasTypeOrSubtype(lhs, - JavaClassNames.JAVA_UTIL_DATE, - JavaClassNames.JAVA_UTIL_CALENDAR); + final String type = TypeUtils.expressionHasTypeOrSubtype(lhs, CommonClassNames.JAVA_UTIL_DATE, CommonClassNames.JAVA_UTIL_CALENDAR); if (type == null) { return; } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java index 82444f0de7..3606974a7d 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/bugs/ArchaicSystemPropertyAccessInspection.java @@ -15,20 +15,18 @@ */ package com.intellij.java.impl.ig.bugs; -import jakarta.annotation.Nonnull; - -import consulo.annotation.component.ExtensionImpl; -import consulo.language.editor.inspection.ProblemDescriptor; import com.intellij.java.language.psi.*; -import consulo.project.Project; -import consulo.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; -import consulo.language.util.IncorrectOperationException; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; -import consulo.java.language.module.util.JavaClassNames; +import consulo.annotation.component.ExtensionImpl; +import consulo.language.editor.inspection.ProblemDescriptor; +import consulo.language.psi.PsiElement; +import consulo.language.util.IncorrectOperationException; +import consulo.project.Project; +import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @ExtensionImpl @@ -174,17 +172,15 @@ public void visitMethodCallExpression( } static boolean isIntegerGetInteger(PsiMethodCallExpression expression) { - return isCallTo(expression, JavaClassNames.JAVA_LANG_INTEGER, - "getInteger"); + return isCallTo(expression, CommonClassNames.JAVA_LANG_INTEGER, "getInteger"); } static boolean isLongGetLong(PsiMethodCallExpression expression) { - return isCallTo(expression, JavaClassNames.JAVA_LANG_LONG, "getLong"); + return isCallTo(expression, CommonClassNames.JAVA_LANG_LONG, "getLong"); } static boolean isBooleanGetBoolean(PsiMethodCallExpression expression) { - return isCallTo(expression, JavaClassNames.JAVA_LANG_BOOLEAN, - "getBoolean"); + return isCallTo(expression, CommonClassNames.JAVA_LANG_BOOLEAN, "getBoolean"); } private static boolean isCallTo(PsiMethodCallExpression expression, diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java index 96dfebbddb..9e21576bfc 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractClassExtendsConcreteClassInspection.java @@ -15,13 +15,13 @@ */ package com.intellij.java.impl.ig.inheritance; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiModifier; import com.siyeh.ig.BaseInspection; 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; @ExtensionImpl @@ -65,7 +65,7 @@ public void visitClass(@Nonnull PsiClass aClass) { return; } final String superclassName = superClass.getQualifiedName(); - if (JavaClassNames.JAVA_LANG_OBJECT.equals(superclassName)) { + if (CommonClassNames.JAVA_LANG_OBJECT.equals(superclassName)) { return; } registerClassError(aClass); diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java index c2deb2717e..bc3eba58a5 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesAbstractMethodInspection.java @@ -165,7 +165,7 @@ private boolean haveSameAnnotations(PsiModifierListOwner owner1, PsiModifierList final Set annotationsSet = new HashSet(Arrays.asList(superAnnotations)); for (PsiAnnotation annotation : annotations) { final String qualifiedName = annotation.getQualifiedName(); - if (JavaClassNames.JAVA_LANG_OVERRIDE.equals(qualifiedName)) { + if (CommonClassNames.JAVA_LANG_OVERRIDE.equals(qualifiedName)) { continue; } if (!annotationsSet.contains(annotation)) { diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java index 3629ab2c9c..692d29cd69 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/inheritance/AbstractMethodOverridesConcreteMethodInspection.java @@ -15,6 +15,7 @@ */ package com.intellij.java.impl.ig.inheritance; +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.PsiModifier; @@ -22,7 +23,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; @ExtensionImpl @@ -74,7 +74,7 @@ public void visitMethod(@Nonnull PsiMethod method) { } final String superClassName = superClass.getQualifiedName(); if (!superClass.isInterface() && - !JavaClassNames.JAVA_LANG_OBJECT.equals(superClassName) && + !CommonClassNames.JAVA_LANG_OBJECT.equals(superClassName) && !superMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { registerMethodError(method); return; diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java index 9d245a1e0e..af4df65c50 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsBetweenInconvertibleTypesInspection.java @@ -23,7 +23,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 consulo.util.lang.StringUtil; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @@ -88,7 +87,7 @@ public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expressio final PsiExpressionList argumentList = expression.getArgumentList(); final PsiExpression[] arguments = argumentList.getExpressions(); final int argumentIndex; - if (firstParameterType.equalsToText(JavaClassNames.JAVA_LANG_STRING)) { + if (firstParameterType.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { if (arguments.length < 3) { return; } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsMayBeAssertSameInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsMayBeAssertSameInspection.java index c169ee0b4f..bc9d1433e7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsMayBeAssertSameInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/junit/AssertEqualsMayBeAssertSameInspection.java @@ -23,7 +23,6 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiManager; @@ -153,7 +152,7 @@ private static boolean couldBeAssertSameArgument(PsiExpression expression) { final PsiMethod[] methods = argumentClass.findMethodsByName("equals", true); final PsiManager manager = expression.getManager(); final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(manager.getProject()); - final PsiClass objectClass = psiFacade.findClass(JavaClassNames.JAVA_LANG_OBJECT, argumentClass.getResolveScope()); + final PsiClass objectClass = psiFacade.findClass(CommonClassNames.JAVA_LANG_OBJECT, argumentClass.getResolveScope()); if (objectClass == null) { return false; } diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/performance/ArraysAsListWithZeroOrOneArgumentInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/performance/ArraysAsListWithZeroOrOneArgumentInspection.java index df0eef941e..20d4d22b72 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/performance/ArraysAsListWithZeroOrOneArgumentInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/performance/ArraysAsListWithZeroOrOneArgumentInspection.java @@ -21,7 +21,6 @@ import com.siyeh.ig.InspectionGadgetsFix; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.inspection.ProblemDescriptor; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; @@ -128,7 +127,7 @@ else if (arguments.length != 0) { return; } final String className = containingClass.getQualifiedName(); - if (!JavaClassNames.JAVA_UTIL_ARRAYS.equals(className)) { + if (!CommonClassNames.JAVA_UTIL_ARRAYS.equals(className)) { return; } registerMethodCallError(expression, Boolean.valueOf(arguments.length == 0)); diff --git a/plugin/src/main/java/com/intellij/java/impl/ig/threading/AccessToNonThreadSafeStaticFieldFromInstanceInspection.java b/plugin/src/main/java/com/intellij/java/impl/ig/threading/AccessToNonThreadSafeStaticFieldFromInstanceInspection.java index dd671662b5..1ba242b69e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ig/threading/AccessToNonThreadSafeStaticFieldFromInstanceInspection.java +++ b/plugin/src/main/java/com/intellij/java/impl/ig/threading/AccessToNonThreadSafeStaticFieldFromInstanceInspection.java @@ -22,7 +22,6 @@ import com.siyeh.ig.ui.ExternalizableStringSet; import com.siyeh.localize.InspectionGadgetsLocalize; import consulo.annotation.component.ExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; import consulo.util.lang.StringUtil; @@ -43,7 +42,7 @@ public class AccessToNonThreadSafeStaticFieldFromInstanceInspection public String nonThreadSafeTypes = ""; @SuppressWarnings("PublicField") public final ExternalizableStringSet nonThreadSafeClasses = - new ExternalizableStringSet("java.text.SimpleDateFormat", JavaClassNames.JAVA_UTIL_CALENDAR); + new ExternalizableStringSet("java.text.SimpleDateFormat", CommonClassNames.JAVA_UTIL_CALENDAR); public AccessToNonThreadSafeStaticFieldFromInstanceInspection() { if (nonThreadSafeTypes.length() != 0) { diff --git a/plugin/src/main/java/com/intellij/java/impl/ipp/adapter/AdapterToListenerIntention.java b/plugin/src/main/java/com/intellij/java/impl/ipp/adapter/AdapterToListenerIntention.java index 1b75622fff..9491186891 100644 --- a/plugin/src/main/java/com/intellij/java/impl/ipp/adapter/AdapterToListenerIntention.java +++ b/plugin/src/main/java/com/intellij/java/impl/ipp/adapter/AdapterToListenerIntention.java @@ -185,7 +185,7 @@ private static void implementMethodInClass(@Nonnull PsiMethod method, CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class); if (codeStyleSettings.INSERT_OVERRIDE_ANNOTATION && PsiUtil.isLanguageLevel6OrHigher(aClass)) { - modifierList.addAnnotation(JavaClassNames.JAVA_LANG_OVERRIDE); + modifierList.addAnnotation(CommonClassNames.JAVA_LANG_OVERRIDE); } final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerDialog.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerDialog.java index 72cf5db32c..b833e38f8f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerDialog.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerDialog.java @@ -24,7 +24,6 @@ import com.intellij.java.language.psi.codeStyle.VariableKind; import com.intellij.java.language.psi.util.TypeConversionUtil; import consulo.application.HelpManager; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.refactoring.localize.RefactoringLocalize; import consulo.language.editor.refactoring.ui.NameSuggestionsField; import consulo.language.editor.refactoring.util.CommonRefactoringUtil; @@ -96,7 +95,7 @@ public String apply(PsiType psiType) { if (psiType instanceof PsiClassType) { type = TypeConversionUtil.erasure(psiType); } - if (type == null || type.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)) return ""; + if (type == null || type.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) return ""; if (type instanceof PsiArrayType) { type = type.getDeepComponentType(); } diff --git a/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerHandler.java b/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerHandler.java index ef260bee5a..036c63d97a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/refactoring/anonymousToInner/AnonymousToInnerHandler.java @@ -21,12 +21,9 @@ import com.intellij.java.language.impl.psi.impl.PsiDiamondTypeUtil; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; -import consulo.application.Application; -import consulo.application.ApplicationManager; import consulo.codeEditor.Editor; import consulo.codeEditor.ScrollType; import consulo.dataContext.DataContext; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.codeStyle.CodeStyleManager; import consulo.language.editor.refactoring.RefactoringBundle; import consulo.language.editor.refactoring.action.RefactoringActionHandler; @@ -43,13 +40,11 @@ import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; -import consulo.ui.annotation.RequiredUIAccess; import consulo.undoRedo.CommandProcessor; +import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; import org.jetbrains.annotations.NonNls; -import jakarta.annotation.Nonnull; - import java.util.*; public class AnonymousToInnerHandler implements RefactoringActionHandler { @@ -330,7 +325,7 @@ private PsiClass createClass(String name) throws IncorrectOperationException { } PsiJavaCodeReferenceElement baseClassRef = myAnonClass.getBaseClassReference(); PsiClass baseClass = (PsiClass)baseClassRef.resolve(); - if (baseClass == null || !JavaClassNames.JAVA_LANG_OBJECT.equals(baseClass.getQualifiedName())) { + if (baseClass == null || !CommonClassNames.JAVA_LANG_OBJECT.equals(baseClass.getQualifiedName())) { PsiReferenceList refList = baseClass != null && baseClass.isInterface() ? aClass.getImplementsList() : aClass.getExtendsList(); diff --git a/plugin/src/test/java_/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java b/plugin/src/test/java_/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java index 60e0366b84..a32b142027 100644 --- a/plugin/src/test/java_/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java +++ b/plugin/src/test/java_/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java @@ -17,7 +17,7 @@ import static org.junit.Assert.assertNotNull; -import consulo.java.language.module.util.JavaClassNames; +import com.intellij.java.language.psi.CommonClassNames; import jakarta.annotation.Nonnull; import org.jetbrains.annotations.NonNls; @@ -321,7 +321,7 @@ public void testIDEA57334() { public void testIDEA113225() throws Exception { doTest5(false); } public void testJavaUtilCollections_NoVerify() throws Exception { - PsiClass collectionsClass = getJavaFacade().findClass(JavaClassNames.JAVA_UTIL_COLLECTIONS, GlobalSearchScope.moduleWithLibrariesScope(getModule())); + PsiClass collectionsClass = getJavaFacade().findClass(CommonClassNames.JAVA_UTIL_COLLECTIONS, GlobalSearchScope.moduleWithLibrariesScope(getModule())); assertNotNull(collectionsClass); collectionsClass = (PsiClass)collectionsClass.getNavigationElement(); final String text = collectionsClass.getContainingFile().getText(); diff --git a/plugin/src/test/java_/com/intellij/codeInsight/daemon/ImportHelperTest.java b/plugin/src/test/java_/com/intellij/codeInsight/daemon/ImportHelperTest.java index 771e839785..987227233f 100644 --- a/plugin/src/test/java_/com/intellij/codeInsight/daemon/ImportHelperTest.java +++ b/plugin/src/test/java_/com/intellij/codeInsight/daemon/ImportHelperTest.java @@ -8,6 +8,7 @@ import java.io.File; import java.util.List; +import com.intellij.java.language.psi.*; import consulo.undoRedo.UndoManager; import consulo.virtualFileSystem.LocalFileSystem; import org.jetbrains.annotations.NonNls; @@ -28,13 +29,7 @@ import consulo.language.impl.internal.psi.LoadTextUtil; import consulo.util.lang.StringUtil; import consulo.virtualFileSystem.VirtualFile; -import consulo.java.language.module.util.JavaClassNames; -import com.intellij.java.language.psi.JavaPsiFacade; -import com.intellij.java.language.psi.PsiClass; import consulo.language.psi.PsiFile; -import com.intellij.java.language.psi.PsiImportStatementBase; -import com.intellij.java.language.psi.PsiJavaCodeReferenceElement; -import com.intellij.java.language.psi.PsiJavaFile; import consulo.language.psi.PsiReference; import consulo.language.codeStyle.CodeStyleSettings; import consulo.language.codeStyle.CodeStyleSettingsManager; @@ -91,19 +86,19 @@ public void run() { try { - checkAddImport(file, JavaClassNames.JAVA_UTIL_LIST, JavaClassNames.JAVA_UTIL_LIST); - checkAddImport(file, JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_LIST); - checkAddImport(file, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST); - checkAddImport(file, JavaClassNames.JAVA_UTIL_SORTED_MAP, JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, JavaClassNames.JAVA_UTIL_SORTED_MAP); - checkAddImport(file, JavaClassNames.JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, JavaClassNames.JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_SORTED_MAP); - checkAddImport(file, "java.util.AbstractList", "java.util.AbstractList", JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, JavaClassNames.JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_SORTED_MAP); - checkAddImport(file, "java.util.AbstractList", "java.util.AbstractList", JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, JavaClassNames - .JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_SORTED_MAP); - checkAddImport(file, "java.util.TreeMap", "java.util.AbstractList", JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, JavaClassNames.JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_SORTED_MAP, "java.util.TreeMap"); - checkAddImport(file, "java.util.concurrent.atomic.AtomicBoolean", "java.util.AbstractList", JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, - JavaClassNames.JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_SORTED_MAP, "java.util.TreeMap", "java.util.concurrent.atomic.AtomicBoolean"); - checkAddImport(file, JavaClassNames.JAVA_IO_FILE, JavaClassNames.JAVA_IO_FILE, "java.util.AbstractList", JavaClassNames.JAVA_UTIL_ARRAY_LIST, JavaClassNames.JAVA_UTIL_HASH_MAP, JavaClassNames.JAVA_UTIL_LIST, - JavaClassNames.JAVA_UTIL_MAP, JavaClassNames.JAVA_UTIL_SORTED_MAP, "java.util.TreeMap", "java.util.concurrent.atomic.AtomicBoolean"); + checkAddImport(file, CommonClassNames.JAVA_UTIL_LIST, CommonClassNames.JAVA_UTIL_LIST); + checkAddImport(file, CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_LIST); + checkAddImport(file, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST); + checkAddImport(file, CommonClassNames.JAVA_UTIL_SORTED_MAP, CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, CommonClassNames.JAVA_UTIL_SORTED_MAP); + checkAddImport(file, CommonClassNames.JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, CommonClassNames.JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_SORTED_MAP); + checkAddImport(file, "java.util.AbstractList", "java.util.AbstractList", CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, CommonClassNames.JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_SORTED_MAP); + checkAddImport(file, "java.util.AbstractList", "java.util.AbstractList", CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, CommonClassNames + .JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_SORTED_MAP); + checkAddImport(file, "java.util.TreeMap", "java.util.AbstractList", CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, CommonClassNames.JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_SORTED_MAP, "java.util.TreeMap"); + checkAddImport(file, "java.util.concurrent.atomic.AtomicBoolean", "java.util.AbstractList", CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, + CommonClassNames.JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_SORTED_MAP, "java.util.TreeMap", "java.util.concurrent.atomic.AtomicBoolean"); + checkAddImport(file, CommonClassNames.JAVA_IO_FILE, CommonClassNames.JAVA_IO_FILE, "java.util.AbstractList", CommonClassNames.JAVA_UTIL_ARRAY_LIST, CommonClassNames.JAVA_UTIL_HASH_MAP, CommonClassNames.JAVA_UTIL_LIST, + CommonClassNames.JAVA_UTIL_MAP, CommonClassNames.JAVA_UTIL_SORTED_MAP, "java.util.TreeMap", "java.util.concurrent.atomic.AtomicBoolean"); } catch(Throwable e) { @@ -159,7 +154,7 @@ public void run() CodeStyleSettingsManager.getInstance(getProject()).dropTemporarySettings(); } - assertOrder(file, "java.awt.*", JavaClassNames.JAVA_UTIL_MAP, "static java.lang.Math.max", "static java.lang.Math.min", "static javax.swing.SwingConstants.CENTER"); + assertOrder(file, "java.awt.*", CommonClassNames.JAVA_UTIL_MAP, "static java.lang.Math.max", "static java.lang.Math.min", "static javax.swing.SwingConstants.CENTER"); } catch(Throwable e) diff --git a/plugin/src/test/java_/com/intellij/psi/ClsRepositoryUseTest.java b/plugin/src/test/java_/com/intellij/psi/ClsRepositoryUseTest.java index 39677f1456..5653eaa2a5 100644 --- a/plugin/src/test/java_/com/intellij/psi/ClsRepositoryUseTest.java +++ b/plugin/src/test/java_/com/intellij/psi/ClsRepositoryUseTest.java @@ -15,38 +15,30 @@ */ package com.intellij.psi; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; - -import java.io.File; - import com.intellij.java.language.impl.JavaFileType; -import com.intellij.java.language.psi.*; -import consulo.application.ApplicationManager; -import consulo.logging.Logger; -import consulo.module.content.layer.ModifiableRootModel; -import consulo.module.content.ModuleRootManager; -import consulo.content.OrderRootType; -import consulo.ide.impl.idea.openapi.util.io.FileUtil; -import consulo.virtualFileSystem.LocalFileSystem; -import consulo.virtualFileSystem.VirtualFile; -import consulo.virtualFileSystem.VirtualFileFilter; import com.intellij.java.language.impl.psi.impl.java.stubs.PsiMethodStub; -import consulo.language.psi.scope.GlobalSearchScope; +import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.testFramework.IdeaTestUtil; import com.intellij.testFramework.PlatformTestCase; import com.intellij.testFramework.PsiTestCase; import com.intellij.testFramework.PsiTestUtil; +import consulo.application.ApplicationManager; +import consulo.content.OrderRootType; +import consulo.ide.impl.idea.openapi.util.io.FileUtil; import consulo.java.impl.module.extension.JavaModuleExtensionImpl; import consulo.java.impl.module.extension.JavaMutableModuleExtensionImpl; -import consulo.java.language.module.util.JavaClassNames; +import consulo.language.psi.scope.GlobalSearchScope; +import consulo.logging.Logger; +import consulo.module.content.ModuleRootManager; +import consulo.module.content.layer.ModifiableRootModel; +import consulo.virtualFileSystem.LocalFileSystem; +import consulo.virtualFileSystem.VirtualFile; +import consulo.virtualFileSystem.VirtualFileFilter; + +import java.io.File; + +import static org.junit.Assert.*; @PlatformTestCase.WrapInCommand public abstract class ClsRepositoryUseTest extends PsiTestCase { @@ -418,7 +410,7 @@ public void testComponentType() throws Exception { LOG.assertTrue(type instanceof PsiArrayType); PsiType componentType = ((PsiArrayType)type).getComponentType(); - assertTrue(componentType.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)); + assertTrue(componentType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)); assertEquals("Object", componentType.getPresentableText()); assertFalse(componentType instanceof PsiPrimitiveType); assertFalse(componentType instanceof PsiArrayType); @@ -437,7 +429,7 @@ public void testTypeReference() throws Exception { PsiType type2 = ((PsiArrayType)field2.getType()).getComponentType(); assertTrue(type2 instanceof PsiClassType); - assertTrue(type2.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)); + assertTrue(type2.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)); assertEquals("Object", type2.getPresentableText()); } @@ -449,7 +441,7 @@ public void testResolveTypeReference() throws Exception { PsiType type1 = aClass.getFields()[1].getType(); PsiElement target1 = PsiUtil.resolveClassInType(type1); assertNotNull(target1); - PsiClass objectClass = myJavaFacade.findClasses(JavaClassNames.JAVA_LANG_OBJECT, RESOLVE_SCOPE)[1]; + PsiClass objectClass = myJavaFacade.findClasses(CommonClassNames.JAVA_LANG_OBJECT, RESOLVE_SCOPE)[1]; assertEquals(objectClass, target1); } @@ -481,7 +473,7 @@ public void testExtendsList() throws Exception { PsiClassType[] refs = list.getReferencedTypes(); assertEquals(1, refs.length); assertEquals("ArrayList", refs[0].getPresentableText()); - assertEquals(JavaClassNames.JAVA_UTIL_ARRAY_LIST, refs[0].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_UTIL_ARRAY_LIST, refs[0].getCanonicalText()); } public void testImplementsList() throws Exception { @@ -494,7 +486,7 @@ public void testImplementsList() throws Exception { PsiClassType[] refs = list.getReferencedTypes(); assertEquals(1, refs.length); assertEquals("Cloneable", refs[0].getPresentableText()); - assertEquals(JavaClassNames.JAVA_LANG_CLONEABLE, refs[0].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_CLONEABLE, refs[0].getCanonicalText()); } public void testThrowsList() throws Exception { @@ -508,8 +500,8 @@ public void testThrowsList() throws Exception { assertEquals(2, refs.length); assertEquals("Exception", refs[0].getPresentableText()); assertEquals("IOException", refs[1].getPresentableText()); - assertEquals(JavaClassNames.JAVA_LANG_EXCEPTION, refs[0].getCanonicalText()); - assertEquals(JavaClassNames.JAVA_IO_IO_EXCEPTION, refs[1].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_EXCEPTION, refs[0].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_IO_IO_EXCEPTION, refs[1].getCanonicalText()); } @@ -531,12 +523,12 @@ public void testParameters() throws Exception { PsiType type2 = parameters[1].getType(); assertEquals("Object", type2.getPresentableText()); - assertTrue(type2.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)); + assertTrue(type2.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)); assertFalse(type2 instanceof PsiArrayType); assertFalse(type2 instanceof PsiPrimitiveType); PsiClass target2 = PsiUtil.resolveClassInType(type2); assertNotNull(target2); - PsiClass objectClass = myJavaFacade.findClasses(JavaClassNames.JAVA_LANG_OBJECT, RESOLVE_SCOPE)[1]; + PsiClass objectClass = myJavaFacade.findClasses(CommonClassNames.JAVA_LANG_OBJECT, RESOLVE_SCOPE)[1]; assertEquals(objectClass, target2); parameters[0].getModifierList(); @@ -545,7 +537,7 @@ public void testParameters() throws Exception { public void testGenericClass() throws Exception { disableJdk(); - PsiClass map = myJavaFacade.findClass(JavaClassNames.JAVA_UTIL_HASH_MAP, RESOLVE_SCOPE); + PsiClass map = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_HASH_MAP, RESOLVE_SCOPE); assert map != null; PsiMethod entrySet = map.findMethodsByName("entrySet", false)[0]; PsiClassType ret = (PsiClassType)entrySet.getReturnType(); @@ -553,7 +545,7 @@ public void testGenericClass() throws Exception { final PsiClassType.ClassResolveResult setResolveResult = ret.resolveGenerics(); final PsiClass setResolveResultElement = setResolveResult.getElement(); assert setResolveResultElement != null : setResolveResult; - assertEquals(JavaClassNames.JAVA_UTIL_SET, setResolveResultElement.getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_SET, setResolveResultElement.getQualifiedName()); final PsiTypeParameter typeParameter = setResolveResultElement.getTypeParameters()[0]; final PsiType substitutedResult = setResolveResult.getSubstitutor().substitute(typeParameter); @@ -564,7 +556,7 @@ public void testGenericClass() throws Exception { final PsiClassType.ClassResolveResult setTypeResolveResult = setType.resolveGenerics(); final PsiClass setTypeResolveResultElement = setTypeResolveResult.getElement(); assert setTypeResolveResultElement != null : setTypeResolveResult; - assertEquals(JavaClassNames.JAVA_UTIL_MAP_ENTRY, setTypeResolveResultElement.getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_MAP_ENTRY, setTypeResolveResultElement.getQualifiedName()); final PsiTypeParameter[] typeParameters = setTypeResolveResultElement.getTypeParameters(); assertEquals(2, typeParameters.length); PsiType[] mapParams = new PsiType[]{ @@ -591,7 +583,7 @@ private void disableJdk() { public void testGenericReturnType() throws Exception { disableJdk(); - final PsiClass map = myJavaFacade.findClass(JavaClassNames.JAVA_UTIL_MAP, RESOLVE_SCOPE); + final PsiClass map = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_MAP, RESOLVE_SCOPE); assert map != null; final PsiElementFactory factory = myJavaFacade.getElementFactory(); final PsiClassType typeMapStringToInteger = @@ -632,8 +624,8 @@ public void testGenericInheritance() throws Exception { public void testSimplerGenericInheritance() throws Exception { PsiElementFactory factory = myJavaFacade.getElementFactory(); - PsiClass map = myJavaFacade.findClass(JavaClassNames.JAVA_UTIL_MAP, RESOLVE_SCOPE); - PsiClass hashMap = myJavaFacade.findClass(JavaClassNames.JAVA_UTIL_HASH_MAP, RESOLVE_SCOPE); + PsiClass map = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_MAP, RESOLVE_SCOPE); + PsiClass hashMap = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_HASH_MAP, RESOLVE_SCOPE); assert map != null && hashMap != null; assertTrue(factory.createType(map).isAssignableFrom(factory.createType(hashMap))); } @@ -762,7 +754,7 @@ public void testInvariantParsing() throws Exception { public void testInvariantParsing2() throws Exception { disableJdk(); - final PsiClass collection = myJavaFacade.findClass(JavaClassNames.JAVA_UTIL_COLLECTION, RESOLVE_SCOPE); + final PsiClass collection = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_COLLECTION, RESOLVE_SCOPE); assertNotNull(collection); final PsiMethod[] methods = collection.findMethodsByName("removeAll", false); assertEquals(1, methods.length); diff --git a/plugin/src/test/java_/com/intellij/psi/CodeFragmentsTest.java b/plugin/src/test/java_/com/intellij/psi/CodeFragmentsTest.java index 59dfc15ded..1b7031e029 100644 --- a/plugin/src/test/java_/com/intellij/psi/CodeFragmentsTest.java +++ b/plugin/src/test/java_/com/intellij/psi/CodeFragmentsTest.java @@ -1,17 +1,17 @@ package com.intellij.psi; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.JavaCodeFragmentFactory; import com.intellij.java.language.psi.PsiClass; import com.intellij.testFramework.PlatformTestCase; import com.intellij.testFramework.PsiTestCase; -import consulo.java.language.module.util.JavaClassNames; import consulo.language.psi.scope.GlobalSearchScope; @PlatformTestCase.WrapInCommand public abstract class CodeFragmentsTest extends PsiTestCase{ public void testAddImport() throws Exception { PsiCodeFragment fragment = JavaCodeFragmentFactory.getInstance(myProject).createExpressionCodeFragment("AAA.foo()", null, null, false); - PsiClass arrayListClass = myJavaFacade.findClass(JavaClassNames.JAVA_UTIL_ARRAY_LIST, GlobalSearchScope.allScope(getProject())); + PsiClass arrayListClass = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_ARRAY_LIST, GlobalSearchScope.allScope(getProject())); PsiReference ref = fragment.findReferenceAt(0); ref.bindToElement(arrayListClass); assertEquals("ArrayList.foo()", fragment.getText()); diff --git a/plugin/src/test/java_/com/intellij/psi/ConstantValuesTest.java b/plugin/src/test/java_/com/intellij/psi/ConstantValuesTest.java index 18988424c4..b24698b92c 100644 --- a/plugin/src/test/java_/com/intellij/psi/ConstantValuesTest.java +++ b/plugin/src/test/java_/com/intellij/psi/ConstantValuesTest.java @@ -244,7 +244,7 @@ public void testString() assertNotNull(field); PsiLiteralExpression initializer = (PsiLiteralExpression) field.getInitializer(); assertNotNull(initializer); - assertTrue(initializer.getType().equalsToText(JavaClassNames.JAVA_LANG_STRING)); + assertTrue(initializer.getType().equalsToText(CommonClassNames.JAVA_LANG_STRING)); assertEquals("a\r\n\"bcd", initializer.getValue()); assertEquals("\"a\\r\\n\\\"bcd\"", initializer.getText()); diff --git a/plugin/src/test/java_/com/intellij/psi/Src15RepositoryUseTest.java b/plugin/src/test/java_/com/intellij/psi/Src15RepositoryUseTest.java index 435f87d90b..9cd5ab870f 100644 --- a/plugin/src/test/java_/com/intellij/psi/Src15RepositoryUseTest.java +++ b/plugin/src/test/java_/com/intellij/psi/Src15RepositoryUseTest.java @@ -120,17 +120,17 @@ private static void doTestStaticImports(final PsiJavaFile javaFile, boolean okTo final PsiElement element1 = classReference1.resolveTargetClass(); assertNotNull(element1); assertTrue(element1 instanceof PsiClass); - assertEquals(JavaClassNames.JAVA_UTIL_ARRAYS, ((PsiClass)element1).getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_ARRAYS, ((PsiClass)element1).getQualifiedName()); final PsiImportStaticStatement classReference3 = importStaticStatements[3]; final PsiElement element3 = classReference3.resolveTargetClass(); assertNotNull(element3); assertTrue(element3 instanceof PsiClass); - assertEquals(JavaClassNames.JAVA_UTIL_ARRAYS, ((PsiClass)element3).getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_ARRAYS, ((PsiClass)element3).getQualifiedName()); if (okToLoadTree) { - assertEquals(JavaClassNames.JAVA_UTIL_COLLECTIONS, getText(importStaticStatements[0])); - assertEquals(JavaClassNames.JAVA_UTIL_ARRAYS, getText(importStaticStatements[1])); + assertEquals(CommonClassNames.JAVA_UTIL_COLLECTIONS, getText(importStaticStatements[0])); + assertEquals(CommonClassNames.JAVA_UTIL_ARRAYS, getText(importStaticStatements[1])); assertEquals("java.util.Collections.sort", getText(importStaticStatements[2])); assertEquals("java.util.Arrays.sort", getText(importStaticStatements[3])); } @@ -147,14 +147,14 @@ public void testEnum() throws Exception { assertTrue(enumClass.isEnum()); final PsiClass superClass = enumClass.getSuperClass(); assertNotNull(superClass); - assertEquals(JavaClassNames.JAVA_LANG_ENUM, superClass.getQualifiedName()); + assertEquals(CommonClassNames.JAVA_LANG_ENUM, superClass.getQualifiedName()); assertTrue(enumClass.isInheritor(superClass, false)); final PsiClassType[] superTypes = enumClass.getSuperTypes(); assertEquals(1, superTypes.length); assertEquals("java.lang.Enum", superTypes[0].getCanonicalText()); final PsiClass[] supers = enumClass.getSupers(); assertEquals(1, supers.length); - assertEquals(JavaClassNames.JAVA_LANG_ENUM, supers[0].getQualifiedName()); + assertEquals(CommonClassNames.JAVA_LANG_ENUM, supers[0].getQualifiedName()); final PsiClassType[] extendsListTypes = enumClass.getExtendsListTypes(); assertEquals(1, extendsListTypes.length); assertEquals("java.lang.Enum", extendsListTypes[0].getCanonicalText()); diff --git a/plugin/src/test/java_/com/intellij/psi/SrcRepositoryUseTest.java b/plugin/src/test/java_/com/intellij/psi/SrcRepositoryUseTest.java index 30d37dbc1f..95e25ae31c 100644 --- a/plugin/src/test/java_/com/intellij/psi/SrcRepositoryUseTest.java +++ b/plugin/src/test/java_/com/intellij/psi/SrcRepositoryUseTest.java @@ -15,45 +15,40 @@ */ package com.intellij.psi; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -import java.io.File; -import java.io.IOException; - +import com.intellij.java.indexing.search.searches.ClassInheritorsSearch; import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.util.PsiUtil; +import com.intellij.openapi.projectRoots.impl.ProjectRootUtil; +import com.intellij.testFramework.IdeaTestUtil; +import com.intellij.testFramework.PlatformTestCase; +import com.intellij.testFramework.PsiTestCase; +import com.intellij.testFramework.PsiTestUtil; import consulo.application.ApplicationManager; -import consulo.ide.ServiceManager; import consulo.document.FileDocumentManager; -import com.intellij.openapi.projectRoots.impl.ProjectRootUtil; -import consulo.module.content.layer.ContentEntry; -import consulo.module.content.layer.ContentFolder; -import consulo.module.content.layer.ModifiableRootModel; -import consulo.module.content.ModuleRootManager; -import consulo.logging.Logger; -import consulo.util.dataholder.Key; import consulo.document.util.TextRange; +import consulo.ide.ServiceManager; import consulo.ide.impl.idea.openapi.util.io.FileUtil; import consulo.ide.impl.idea.openapi.vfs.VfsUtilCore; -import consulo.virtualFileSystem.VirtualFile; -import consulo.virtualFileSystem.VirtualFileFilter; -import consulo.language.impl.psi.PsiFileImpl; +import consulo.language.editor.refactoring.rename.RenameProcessor; import consulo.language.impl.ast.CompositeElement; -import consulo.language.psi.scope.GlobalSearchScope; -import com.intellij.java.indexing.search.searches.ClassInheritorsSearch; import consulo.language.impl.internal.psi.diff.BlockSupport; -import com.intellij.java.language.psi.util.PsiUtil; -import consulo.language.editor.refactoring.rename.RenameProcessor; -import com.intellij.testFramework.IdeaTestUtil; -import com.intellij.testFramework.PlatformTestCase; -import com.intellij.testFramework.PsiTestCase; -import com.intellij.testFramework.PsiTestUtil; -import consulo.java.language.module.util.JavaClassNames; +import consulo.language.impl.psi.PsiFileImpl; +import consulo.language.psi.scope.GlobalSearchScope; +import consulo.logging.Logger; +import consulo.module.content.ModuleRootManager; +import consulo.module.content.layer.ContentEntry; +import consulo.module.content.layer.ContentFolder; +import consulo.module.content.layer.ModifiableRootModel; import consulo.roots.ContentFolderScopes; import consulo.roots.impl.ProductionContentFolderTypeProvider; +import consulo.util.dataholder.Key; +import consulo.virtualFileSystem.VirtualFile; +import consulo.virtualFileSystem.VirtualFileFilter; + +import java.io.File; +import java.io.IOException; + +import static org.junit.Assert.*; @SuppressWarnings("ConstantConditions") @PlatformTestCase.WrapInCommand @@ -114,8 +109,8 @@ public void testClassParameter() { assertEquals(params[0].getName(), "A"); assertEquals(params[1].getName(), "B"); - assertEquals(JavaClassNames.JAVA_LANG_STRING, params[0].getSupers()[0].getQualifiedName()); - assertEquals(JavaClassNames.JAVA_LANG_OBJECT, params[1].getSupers()[0].getQualifiedName()); + assertEquals(CommonClassNames.JAVA_LANG_STRING, params[0].getSupers()[0].getQualifiedName()); + assertEquals(CommonClassNames.JAVA_LANG_OBJECT, params[1].getSupers()[0].getQualifiedName()); teardownLoadingFilter(); } @@ -201,8 +196,8 @@ public void testResolveSuperClass(){ PsiClass aClass = classes[0]; PsiClass[] superTypes = aClass.getSupers(); LOG.assertTrue(superTypes.length == 2); - LOG.assertTrue(superTypes[0].getQualifiedName().equals(JavaClassNames.JAVA_LANG_STRING)); - LOG.assertTrue(superTypes[1].getQualifiedName().equals(JavaClassNames.JAVA_LANG_RUNNABLE)); + LOG.assertTrue(superTypes[0].getQualifiedName().equals(CommonClassNames.JAVA_LANG_STRING)); + LOG.assertTrue(superTypes[1].getQualifiedName().equals(CommonClassNames.JAVA_LANG_RUNNABLE)); teardownLoadingFilter(); } @@ -408,7 +403,7 @@ public void testComponentType() throws Exception { LOG.assertTrue(type instanceof PsiArrayType); PsiType componentType = ((PsiArrayType) type).getComponentType(); - assertTrue(componentType.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)); + assertTrue(componentType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)); assertFalse(componentType instanceof PsiPrimitiveType); assertFalse(componentType instanceof PsiArrayType); @@ -430,7 +425,7 @@ public void testTypeReference() throws Exception { PsiField field3 = aClass.getFields()[2]; PsiType type3 = ((PsiArrayType) field3.getType()).getComponentType(); - assertTrue(type3.equalsToText(JavaClassNames.JAVA_LANG_OBJECT)); + assertTrue(type3.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)); teardownLoadingFilter(); } @@ -470,7 +465,7 @@ public void testResolveTypeReference() throws Exception { PsiType type1 = aClass.getFields()[1].getType(); PsiElement target1 = PsiUtil.resolveClassInType(type1); assertNotNull(target1); - PsiClass objectClass = myJavaFacade.findClass(JavaClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject)); + PsiClass objectClass = myJavaFacade.findClass(CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject)); assertEquals(objectClass, target1); PsiType type2 = aClass.getFields()[1].getType(); @@ -519,7 +514,7 @@ public void testThrowsList() throws Exception { PsiClassType[] refs = list.getReferencedTypes(); assertEquals(2, refs.length); assertEquals("Exception", refs[0].getPresentableText()); - assertEquals(JavaClassNames.JAVA_IO_IO_EXCEPTION, refs[1].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_IO_IO_EXCEPTION, refs[1].getCanonicalText()); teardownLoadingFilter(); } @@ -553,7 +548,7 @@ public void testParameters() throws Exception { assertFalse(type2 instanceof PsiPrimitiveType); PsiClass target2 = PsiUtil.resolveClassInType(type2); assertNotNull(target2); - PsiClass objectClass = myJavaFacade.findClass(JavaClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject)); + PsiClass objectClass = myJavaFacade.findClass(CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject)); assertEquals(objectClass, target2); checkPackAAA(parms[2].getType()); @@ -577,7 +572,7 @@ private static void checkPackAAA(PsiType type) { public void testAnonymousClass() throws Exception { setupLoadingFilter(); - PsiClass cloneableClass = myJavaFacade.findClass(JavaClassNames.JAVA_LANG_CLONEABLE, GlobalSearchScope.allScope(myProject)); + PsiClass cloneableClass = myJavaFacade.findClass(CommonClassNames.JAVA_LANG_CLONEABLE, GlobalSearchScope.allScope(myProject)); PsiClass[] inheritors = ClassInheritorsSearch.search(cloneableClass, GlobalSearchScope.projectScope(myProject), true).toArray(PsiClass.EMPTY_ARRAY); assertEquals(2, inheritors.length); assertTrue(inheritors[0] instanceof PsiAnonymousClass || inheritors[1] instanceof PsiAnonymousClass); @@ -586,7 +581,7 @@ public void testAnonymousClass() throws Exception { PsiClassType baseClassRef = anonClass.getBaseClassType(); assertEquals("Cloneable", baseClassRef.getPresentableText()); assertEquals(cloneableClass, baseClassRef.resolve()); - assertEquals(JavaClassNames.JAVA_LANG_CLONEABLE, baseClassRef.getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_CLONEABLE, baseClassRef.getCanonicalText()); teardownLoadingFilter(); @@ -604,7 +599,7 @@ private void setupLoadingFilter() { public void testAnonymousClass2() throws Exception { setupLoadingFilter(); - PsiClass throwable = myJavaFacade.findClass(JavaClassNames.JAVA_LANG_THROWABLE, GlobalSearchScope.allScope(myProject)); + PsiClass throwable = myJavaFacade.findClass(CommonClassNames.JAVA_LANG_THROWABLE, GlobalSearchScope.allScope(myProject)); PsiClass[] inheritors = ClassInheritorsSearch.search(throwable, GlobalSearchScope.projectScope(myProject), true).toArray(PsiClass.EMPTY_ARRAY); assertEquals(1, inheritors.length); assertTrue(inheritors[0] instanceof PsiAnonymousClass); @@ -613,7 +608,7 @@ public void testAnonymousClass2() throws Exception { PsiClassType baseClassRef = anonClass.getBaseClassType(); assertEquals("Throwable", baseClassRef.getPresentableText()); assertEquals(throwable, baseClassRef.resolve()); - assertEquals(JavaClassNames.JAVA_LANG_THROWABLE, baseClassRef.getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_THROWABLE, baseClassRef.getCanonicalText()); teardownLoadingFilter(); @@ -623,7 +618,7 @@ public void testAnonymousClass2() throws Exception { public void testLocalClass() throws Exception { setupLoadingFilter(); - PsiClass cloneableClass = myJavaFacade.findClass(JavaClassNames.JAVA_LANG_CLONEABLE, GlobalSearchScope.allScope(myProject)); + PsiClass cloneableClass = myJavaFacade.findClass(CommonClassNames.JAVA_LANG_CLONEABLE, GlobalSearchScope.allScope(myProject)); PsiClass[] inheritors = ClassInheritorsSearch.search(cloneableClass, GlobalSearchScope.projectScope(myProject), true).toArray(PsiClass.EMPTY_ARRAY); assertEquals(2, inheritors.length); assertTrue(inheritors[0] instanceof PsiAnonymousClass || inheritors[1] instanceof PsiAnonymousClass); diff --git a/plugin/src/test/java_/com/intellij/psi/TypesTest.java b/plugin/src/test/java_/com/intellij/psi/TypesTest.java index 34f44b6e99..e9b7a83735 100644 --- a/plugin/src/test/java_/com/intellij/psi/TypesTest.java +++ b/plugin/src/test/java_/com/intellij/psi/TypesTest.java @@ -15,22 +15,17 @@ */ package com.intellij.psi; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - +import com.intellij.java.language.impl.psi.impl.JavaPsiFacadeEx; import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.util.PsiUtil; +import com.intellij.testFramework.PsiTestUtil; import consulo.application.ApplicationManager; -import consulo.java.language.module.util.JavaClassNames; +import consulo.language.psi.scope.GlobalSearchScope; import consulo.util.lang.Comparing; import consulo.virtualFileSystem.LocalFileSystem; import consulo.virtualFileSystem.VirtualFile; -import com.intellij.java.language.impl.psi.impl.JavaPsiFacadeEx; -import consulo.language.psi.scope.GlobalSearchScope; -import com.intellij.java.language.psi.util.PsiUtil; -import com.intellij.testFramework.PsiTestUtil; + +import static org.junit.Assert.*; /** * @author dsl @@ -76,9 +71,9 @@ public void testSimpleStuff() throws Exception { final PsiMethod methodFromList = (PsiMethod) resolveResult.getElement(); final PsiType typeOfFirstParameterOfAdd = methodFromList.getParameterList().getParameters()[0].getType(); final PsiType substitutedType = resolveResult.getSubstitutor().substitute(typeOfFirstParameterOfAdd); - final PsiClassType typeA = factory.createTypeByFQClassName(JavaClassNames.JAVA_LANG_STRING); + final PsiClassType typeA = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_STRING); assertEquals(typeA, substitutedType); - assertTrue(typeA.equalsToText(JavaClassNames.JAVA_LANG_STRING)); + assertTrue(typeA.equalsToText(CommonClassNames.JAVA_LANG_STRING)); final PsiType aListIteratorType = ((PsiExpressionStatement) methodStatements[2]).getExpression().getType(); final PsiType aIteratorType = factory.createTypeFromText("test.Iterator", null); @@ -133,7 +128,7 @@ public void testSubstWithInheritor() throws Exception { final PsiMethod methodFromList = (PsiMethod) resolveResult.getElement(); final PsiType typeOfFirstParameterOfAdd = methodFromList.getParameterList().getParameters()[0].getType(); final PsiType substitutedType = resolveResult.getSubstitutor().substitute(typeOfFirstParameterOfAdd); - final PsiType javaLangInteger = factory.createTypeFromText(JavaClassNames.JAVA_LANG_INTEGER, null); + final PsiType javaLangInteger = factory.createTypeFromText(CommonClassNames.JAVA_LANG_INTEGER, null); assertEquals(javaLangInteger, substitutedType); final PsiType intListIteratorReturnType = ((PsiExpressionStatement) methodStatements[2]).getExpression().getType(); @@ -323,7 +318,7 @@ public void testMethodTypeParameter() throws Exception { final PsiStatement[] statements = method.getBody().getStatements(); final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) ((PsiExpressionStatement) statements[1]).getExpression(); - isCollectionUtilSort(methodCallExpression, factory.createTypeFromText(JavaClassNames.JAVA_LANG_INTEGER, null)); + isCollectionUtilSort(methodCallExpression, factory.createTypeFromText(CommonClassNames.JAVA_LANG_INTEGER, null)); final PsiMethodCallExpression methodCallExpression1 = (PsiMethodCallExpression) ((PsiExpressionStatement) statements[3]).getExpression(); isCollectionUtilSort(methodCallExpression1, null); diff --git a/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ExtendsBoundListTest.java b/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ExtendsBoundListTest.java index 8405f96ab5..cc0473f133 100644 --- a/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ExtendsBoundListTest.java +++ b/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ExtendsBoundListTest.java @@ -16,9 +16,8 @@ package com.intellij.psi.impl.source.tree.java; import com.intellij.java.language.psi.*; -import consulo.application.ApplicationManager; import com.intellij.testFramework.LightCodeInsightTestCase; -import consulo.java.language.module.util.JavaClassNames; +import consulo.application.ApplicationManager; /** * @author dsl @@ -63,7 +62,7 @@ public void run() { public void testAddBoundInTheMiddle() throws Exception { final PsiTypeParameter typeParameter = getTypeParameter(); final PsiReferenceList extendsList = typeParameter.getExtendsList(); - final PsiClass cloneableClass = getJavaFacade().findClass(JavaClassNames.JAVA_LANG_CLONEABLE); + final PsiClass cloneableClass = getJavaFacade().findClass(CommonClassNames.JAVA_LANG_CLONEABLE); assertNotNull(cloneableClass); final PsiJavaCodeReferenceElement reference = getJavaFacade().getElementFactory().createClassReferenceElement(cloneableClass); extendsList.addAfter(reference, extendsList.getReferenceElements()[0]); @@ -73,7 +72,7 @@ public void testAddBoundInTheMiddle() throws Exception { public void testAddBoundInFront() throws Exception { final PsiTypeParameter typeParameter = getTypeParameter(); final PsiReferenceList extendsList = typeParameter.getExtendsList(); - final PsiClass cloneableClass = getJavaFacade().findClass(JavaClassNames.JAVA_LANG_CLONEABLE); + final PsiClass cloneableClass = getJavaFacade().findClass(CommonClassNames.JAVA_LANG_CLONEABLE); assertNotNull(cloneableClass); final PsiJavaCodeReferenceElement reference = getJavaFacade().getElementFactory().createClassReferenceElement(cloneableClass); extendsList.addBefore(reference, extendsList.getReferenceElements()[0]); @@ -83,7 +82,7 @@ public void testAddBoundInFront() throws Exception { public void testAddBoundInEnd() throws Exception { final PsiTypeParameter typeParameter = getTypeParameter(); final PsiReferenceList extendsList = typeParameter.getExtendsList(); - final PsiClass cloneableClass = getJavaFacade().findClass(JavaClassNames.JAVA_LANG_CLONEABLE); + final PsiClass cloneableClass = getJavaFacade().findClass(CommonClassNames.JAVA_LANG_CLONEABLE); assertNotNull(cloneableClass); final PsiJavaCodeReferenceElement reference = getJavaFacade().getElementFactory().createClassReferenceElement(cloneableClass); extendsList.addBefore(reference, null); @@ -93,7 +92,7 @@ public void testAddBoundInEnd() throws Exception { public void testAddBound() throws Exception { final PsiTypeParameter typeParameter = getTypeParameter(); final PsiReferenceList extendsList = typeParameter.getExtendsList(); - final PsiClass cloneableClass = getJavaFacade().findClass(JavaClassNames.JAVA_LANG_RUNNABLE); + final PsiClass cloneableClass = getJavaFacade().findClass(CommonClassNames.JAVA_LANG_RUNNABLE); assertNotNull(cloneableClass); final PsiJavaCodeReferenceElement reference = getJavaFacade().getElementFactory().createClassReferenceElement(cloneableClass); extendsList.add(reference); diff --git a/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ShortenClassReferencesTest.java b/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ShortenClassReferencesTest.java index a22fbd6aed..a9439124c2 100644 --- a/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ShortenClassReferencesTest.java +++ b/plugin/src/test/java_/com/intellij/psi/impl/source/tree/java/ShortenClassReferencesTest.java @@ -15,19 +15,16 @@ */ package com.intellij.psi.impl.source.tree.java; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; - +import com.intellij.java.language.impl.psi.impl.JavaPsiFacadeEx; import com.intellij.java.language.psi.*; -import consulo.application.ApplicationManager; -import consulo.undoRedo.CommandProcessor; import com.intellij.java.language.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.java.language.impl.psi.impl.JavaPsiFacadeEx; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; +import consulo.application.ApplicationManager; import consulo.language.codeStyle.PostprocessReformattingAspect; import consulo.language.psi.util.PsiTreeUtil; -import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; -import consulo.java.language.module.util.JavaClassNames; +import consulo.undoRedo.CommandProcessor; + +import static org.junit.Assert.*; /** * @author dsl @@ -53,7 +50,7 @@ public void testSCR22368_1() { assertNotNull(body); PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)body.getStatements()[0]; PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)declarationStatement.getFirstChild().getFirstChild(); - PsiClass javaUtilListClass = facade.findClass(JavaClassNames.JAVA_UTIL_LIST); + PsiClass javaUtilListClass = facade.findClass(CommonClassNames.JAVA_UTIL_LIST); assertNotNull(javaUtilListClass); PsiElement resultingElement = referenceElement.bindToElement(javaUtilListClass); assertEquals("List<", resultingElement.getText()); diff --git a/plugin/src/test/java_/com/intellij/psi/resolve/ResolveClassTest.java b/plugin/src/test/java_/com/intellij/psi/resolve/ResolveClassTest.java index c194adfe71..32f3746e6a 100644 --- a/plugin/src/test/java_/com/intellij/psi/resolve/ResolveClassTest.java +++ b/plugin/src/test/java_/com/intellij/psi/resolve/ResolveClassTest.java @@ -16,18 +16,17 @@ package com.intellij.psi.resolve; import com.intellij.java.language.psi.*; +import com.intellij.testFramework.PlatformTestUtil; +import com.intellij.testFramework.PsiTestUtil; +import com.intellij.testFramework.ResolveTestCase; import consulo.application.ApplicationManager; -import consulo.java.language.module.util.JavaClassNames; +import consulo.ide.impl.idea.openapi.roots.ModuleRootModificationUtil; +import consulo.ide.impl.idea.packageDependencies.DependenciesBuilder; import consulo.module.ModifiableModuleModel; import consulo.module.Module; import consulo.module.ModuleManager; -import consulo.ide.impl.idea.openapi.roots.ModuleRootModificationUtil; import consulo.virtualFileSystem.LocalFileSystem; import consulo.virtualFileSystem.VirtualFile; -import consulo.ide.impl.idea.packageDependencies.DependenciesBuilder; -import com.intellij.testFramework.PlatformTestUtil; -import com.intellij.testFramework.PsiTestUtil; -import com.intellij.testFramework.ResolveTestCase; import java.util.Collections; @@ -123,7 +122,7 @@ public void testImportConflict2() throws Exception { PsiReference ref = configure(); PsiElement target = ((PsiJavaReference)ref).advancedResolve(true).getElement(); assertTrue(target instanceof PsiClass); - assertEquals(JavaClassNames.JAVA_UTIL_DATE, ((PsiClass)target).getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_DATE, ((PsiClass)target).getQualifiedName()); } public void testLocals1() throws Exception { diff --git a/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethod15Test.java b/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethod15Test.java index d1cb2d0b31..dbf1c7aa18 100644 --- a/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethod15Test.java +++ b/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethod15Test.java @@ -1,13 +1,13 @@ package com.intellij.psi.resolve; import com.intellij.java.language.psi.*; -import consulo.language.psi.util.PsiTreeUtil; import com.intellij.java.language.psi.infos.MethodCandidateInfo; +import consulo.language.psi.util.PsiTreeUtil; import consulo.navigation.NavigationItem; -import consulo.java.language.module.util.JavaClassNames; import org.jetbrains.annotations.NonNls; -import static org.junit.Assert.assertThat; + import static org.hamcrest.core.IsInstanceOf.instanceOf; +import static org.junit.Assert.assertThat; /** * @author dsl @@ -20,7 +20,7 @@ public void testStaticImportOnDemand() throws Exception { assertThat(element, instanceOf(PsiMethod.class)); final PsiMethod method = (PsiMethod)element; assertEquals("asList", method.getName()); - assertEquals(JavaClassNames.JAVA_UTIL_ARRAYS, method.getContainingClass().getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_ARRAYS, method.getContainingClass().getQualifiedName()); } public void testStaticImportHidden() throws Exception { @@ -31,7 +31,7 @@ public void testStaticImportHidden() throws Exception { assertNotNull(element); assertThat(element, instanceOf(PsiMethod.class)); final PsiMethod method = (PsiMethod)element; - assertEquals(JavaClassNames.JAVA_LANG_OBJECT, method.getContainingClass().getQualifiedName()); + assertEquals(CommonClassNames.JAVA_LANG_OBJECT, method.getContainingClass().getQualifiedName()); } public void testStaticImportDirect() throws Exception { @@ -41,7 +41,7 @@ public void testStaticImportDirect() throws Exception { assertThat(element, instanceOf(PsiMethod.class)); final PsiMethod method = (PsiMethod)element; assertEquals("asList", method.getName()); - assertEquals(JavaClassNames.JAVA_UTIL_ARRAYS, method.getContainingClass().getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_ARRAYS, method.getContainingClass().getQualifiedName()); assertThat(ref, instanceOf(PsiReferenceExpression.class)); final PsiReferenceExpression refExpr = (PsiReferenceExpression)ref; final JavaResolveResult[] resolveResults = refExpr.multiResolve(false); @@ -62,7 +62,7 @@ public void testStaticImportConflict() throws Exception { assertThat(element, instanceOf(PsiMethod.class)); final PsiMethod method = (PsiMethod)element; assertEquals("sort", method.getName()); - assertEquals(JavaClassNames.JAVA_UTIL_COLLECTIONS, method.getContainingClass().getQualifiedName()); + assertEquals(CommonClassNames.JAVA_UTIL_COLLECTIONS, method.getContainingClass().getQualifiedName()); assertThat(ref, instanceOf(PsiReferenceExpression.class)); final PsiReferenceExpression refExpr = (PsiReferenceExpression)ref; final JavaResolveResult[] resolveResults = refExpr.multiResolve(false); @@ -451,12 +451,12 @@ public void testInheritance4() throws Exception{ public void testExplicitParams1() throws Exception { PsiReference ref = configureByFile(); - assertGenericResolve(ref, "f", new String[] {JavaClassNames.JAVA_LANG_STRING}, JavaClassNames.JAVA_LANG_STRING); + assertGenericResolve(ref, "f", new String[] {CommonClassNames.JAVA_LANG_STRING}, CommonClassNames.JAVA_LANG_STRING); } public void testExplicitParams2() throws Exception { PsiReference ref = configureByFile(); - assertGenericResolve(ref, "f", new String[] {JavaClassNames.JAVA_LANG_INTEGER}, "Foo"); + assertGenericResolve(ref, "f", new String[] {CommonClassNames.JAVA_LANG_INTEGER}, "Foo"); } public void testConstructorExplicitParams() throws Exception { diff --git a/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethodTest.java b/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethodTest.java index 290ceab88b..698881163c 100644 --- a/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethodTest.java +++ b/plugin/src/test/java_/com/intellij/psi/resolve/ResolveMethodTest.java @@ -15,18 +15,13 @@ */ package com.intellij.psi.resolve; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - import com.intellij.java.language.psi.*; -import consulo.content.bundle.Sdk; import com.intellij.java.language.psi.infos.MethodCandidateInfo; import com.intellij.testFramework.IdeaTestUtil; import com.intellij.testFramework.ResolveTestCase; -import consulo.java.language.module.util.JavaClassNames; +import consulo.content.bundle.Sdk; + +import static org.junit.Assert.*; public abstract class ResolveMethodTest extends ResolveTestCase { @Override @@ -201,7 +196,7 @@ public void testSuperOfObject() throws Exception { assertTrue(target instanceof PsiMethod); final PsiMethod method = (PsiMethod)target; assertEquals("clone", method.getName()); - assertEquals(JavaClassNames.JAVA_LANG_OBJECT, method.getContainingClass().getQualifiedName()); + assertEquals(CommonClassNames.JAVA_LANG_OBJECT, method.getContainingClass().getQualifiedName()); } diff --git a/plugin/src/test/java_/com/intellij/psi/resolve/TypeInferenceTest.java b/plugin/src/test/java_/com/intellij/psi/resolve/TypeInferenceTest.java index 1f6b43ac22..8bf4ee0b91 100644 --- a/plugin/src/test/java_/com/intellij/psi/resolve/TypeInferenceTest.java +++ b/plugin/src/test/java_/com/intellij/psi/resolve/TypeInferenceTest.java @@ -1,7 +1,6 @@ package com.intellij.psi.resolve; import com.intellij.java.language.psi.*; -import consulo.java.language.module.util.JavaClassNames; import org.jetbrains.annotations.NonNls; /** @@ -14,7 +13,7 @@ public void testInferInCall1 () throws Exception { assertTrue(type instanceof PsiClassType); PsiType[] paramTypes = ((PsiClassType)type).getParameters(); assertEquals(1, paramTypes.length); - assertEquals(JavaClassNames.JAVA_LANG_OBJECT, paramTypes[0].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_OBJECT, paramTypes[0].getCanonicalText()); } public void testInferInAssign1 () throws Exception { @@ -23,7 +22,7 @@ public void testInferInAssign1 () throws Exception { assertTrue(type instanceof PsiClassType); PsiType[] paramTypes = ((PsiClassType)type).getParameters(); assertEquals(1, paramTypes.length); - assertEquals( JavaClassNames.JAVA_LANG_STRING, paramTypes[0].getCanonicalText()); + assertEquals( CommonClassNames.JAVA_LANG_STRING, paramTypes[0].getCanonicalText()); } public void testInferInAssign2() throws Exception { @@ -32,7 +31,7 @@ public void testInferInAssign2() throws Exception { assertTrue(type instanceof PsiClassType); PsiType[] paramTypes = ((PsiClassType)type).getParameters(); assertEquals(1, paramTypes.length); - assertEquals(JavaClassNames.JAVA_LANG_OBJECT, paramTypes[0].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_OBJECT, paramTypes[0].getCanonicalText()); } public void testInferInCast () throws Exception { @@ -41,7 +40,7 @@ public void testInferInCast () throws Exception { assertTrue(type instanceof PsiClassType); PsiType[] paramTypes = ((PsiClassType)type).getParameters(); assertEquals(1, paramTypes.length); - assertEquals(JavaClassNames.JAVA_LANG_STRING, paramTypes[0].getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_STRING, paramTypes[0].getCanonicalText()); } public void testInferWithBounds () throws Exception { @@ -54,7 +53,7 @@ public void testInferWithBounds1 () throws Exception { PsiSubstitutor substitutor = resolveResult.getSubstitutor(); PsiMethod method = (PsiMethod)resolveResult.getElement(); PsiType type = substitutor.substitute(method.getTypeParameters()[0]); - assertEquals(JavaClassNames.JAVA_LANG_STRING, type.getCanonicalText()); + assertEquals(CommonClassNames.JAVA_LANG_STRING, type.getCanonicalText()); } private PsiReferenceExpression configure() throws Exception { @@ -66,7 +65,7 @@ public void testInferInParamsOnly () throws Exception { } public void testInferRawType () throws Exception { - checkResolvesTo(JavaClassNames.JAVA_LANG_OBJECT); + checkResolvesTo(CommonClassNames.JAVA_LANG_OBJECT); } private void checkResolvesTo(@NonNls String typeName) throws Exception { @@ -85,7 +84,7 @@ public void testInferWithWildcards () throws Exception { } public void testInferWithWildcards1 () throws Exception { - checkResolvesTo(JavaClassNames.JAVA_LANG_STRING); + checkResolvesTo(CommonClassNames.JAVA_LANG_STRING); } public void testInferWithWildcards2 () throws Exception { @@ -109,7 +108,7 @@ public void testInferInReturn () throws Exception { } public void testInferAutoboxed () throws Exception { - checkResolvesTo(JavaClassNames.JAVA_LANG_INTEGER); + checkResolvesTo(CommonClassNames.JAVA_LANG_INTEGER); } public void testInferWithVarargs1 () throws Exception { @@ -145,7 +144,7 @@ public void testSCR41031 () throws Exception { } public void testInferUnchecked () throws Exception { - checkResolvesTo(JavaClassNames.JAVA_LANG_OBJECT); + checkResolvesTo(CommonClassNames.JAVA_LANG_OBJECT); } public void testInferNotNull () throws Exception { diff --git a/plugin/src/test/java_/com/intellij/psi/util/PropertyUtilTest.java b/plugin/src/test/java_/com/intellij/psi/util/PropertyUtilTest.java index d5c3e1d505..631602c571 100644 --- a/plugin/src/test/java_/com/intellij/psi/util/PropertyUtilTest.java +++ b/plugin/src/test/java_/com/intellij/psi/util/PropertyUtilTest.java @@ -1,23 +1,15 @@ -/* - * Created by IntelliJ IDEA. - * User: mike - * Date: Jun 14, 2002 - * Time: 8:05:58 PM - * To change template for new class use - * Code Style | Class Templates options (Tools | IDE Options). - */ package com.intellij.psi.util; -import com.intellij.java.language.psi.PsiElementFactory; -import com.intellij.java.language.psi.PsiField; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiType; +import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PropertyUtil; import com.intellij.testFramework.LightCodeInsightTestCase; import consulo.language.util.IncorrectOperationException; -import consulo.java.language.module.util.JavaClassNames; import org.jetbrains.annotations.NonNls; +/** + * @author mike + * @since 2002-06-14 + */ public abstract class PropertyUtilTest extends LightCodeInsightTestCase { public void testSuggestGetterName() throws Exception { assertEquals("isValid", PropertyUtil.suggestGetterName("valid", getType("boolean"))); @@ -30,7 +22,7 @@ public void testSuggestGetterName() throws Exception { assertEquals("isaURL", PropertyUtil.suggestGetterName(createField("aURL", "boolean"))); assertEquals("getaURL", PropertyUtil.suggestGetterName(createField("aURL", "Object"))); - assertEquals("getBool", PropertyUtil.suggestGetterName(createField("bool", JavaClassNames.JAVA_LANG_BOOLEAN))); + assertEquals("getBool", PropertyUtil.suggestGetterName(createField("bool", CommonClassNames.JAVA_LANG_BOOLEAN))); } public void testSuggestSetterName() throws Exception { @@ -42,7 +34,7 @@ public void testSuggestSetterName() throws Exception { assertEquals("setaURL", PropertyUtil.suggestSetterName("aURL")); assertEquals("setaURL", PropertyUtil.suggestSetterName(createField("aURL", "Object"))); - assertEquals("setBool", PropertyUtil.suggestSetterName(createField("bool", JavaClassNames.JAVA_LANG_BOOLEAN))); + assertEquals("setBool", PropertyUtil.suggestSetterName(createField("bool", CommonClassNames.JAVA_LANG_BOOLEAN))); } public void testSuggestPropertyName() throws Exception { @@ -61,8 +53,8 @@ public void testSuggestPropertyName() throws Exception { public void testBooleanPropertyGetters() { assertTrue(PropertyUtil.hasGetterName(createMethod("isOk", "boolean"))); - assertFalse(PropertyUtil.hasGetterName(createMethod("isOk", JavaClassNames.JAVA_LANG_BOOLEAN))); - assertTrue(PropertyUtil.hasGetterName(createMethod("getOk", JavaClassNames.JAVA_LANG_BOOLEAN))); + assertFalse(PropertyUtil.hasGetterName(createMethod("isOk", CommonClassNames.JAVA_LANG_BOOLEAN))); + assertTrue(PropertyUtil.hasGetterName(createMethod("getOk", CommonClassNames.JAVA_LANG_BOOLEAN))); assertFalse(PropertyUtil.hasGetterName(createMethod("isOk", "int"))); } diff --git a/plugin/src/test/java_/com/intellij/refactoring/ChangeSignaturePropagationTest.java b/plugin/src/test/java_/com/intellij/refactoring/ChangeSignaturePropagationTest.java index f1ccd23ab9..c2ddd9ab01 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/ChangeSignaturePropagationTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/ChangeSignaturePropagationTest.java @@ -1,37 +1,31 @@ package com.intellij.refactoring; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.Set; - import com.intellij.JavaTestUtil; -import com.intellij.java.language.psi.JavaPsiFacade; -import com.intellij.java.language.psi.PsiClass; -import com.intellij.java.language.psi.PsiClassType; -import consulo.java.language.module.util.JavaClassNames; -import consulo.language.psi.PsiElement; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiParameter; -import consulo.language.psi.PsiReference; -import com.intellij.java.language.psi.PsiType; -import consulo.language.psi.scope.GlobalSearchScope; -import com.intellij.java.indexing.search.searches.ClassInheritorsSearch; -import com.intellij.java.indexing.search.searches.MethodReferencesSearch; -import consulo.language.psi.search.ReferencesSearch; -import consulo.language.psi.util.PsiTreeUtil; import com.intellij.java.impl.refactoring.changeSignature.ChangeSignatureProcessor; import com.intellij.java.impl.refactoring.changeSignature.JavaThrownExceptionInfo; import com.intellij.java.impl.refactoring.changeSignature.ParameterInfoImpl; import com.intellij.java.impl.refactoring.changeSignature.ThrownExceptionInfo; import com.intellij.java.impl.refactoring.util.CanonicalTypes; -import consulo.util.collection.ContainerUtil; -import java.util.HashSet; -import consulo.language.editor.TargetElementUtil; +import com.intellij.java.indexing.search.searches.ClassInheritorsSearch; +import com.intellij.java.indexing.search.searches.MethodReferencesSearch; +import com.intellij.java.language.psi.*; import consulo.codeInsight.TargetElementUtilEx; +import consulo.language.editor.TargetElementUtil; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiReference; +import consulo.language.psi.scope.GlobalSearchScope; +import consulo.language.psi.search.ReferencesSearch; +import consulo.language.psi.util.PsiTreeUtil; +import consulo.util.collection.ContainerUtil; import jakarta.annotation.Nonnull; import junit.framework.Assert; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import static org.junit.Assert.assertTrue; + /** * @author ven */ @@ -133,7 +127,7 @@ private void exceptionPropagationTest() throws Exception { private void exceptionPropagationTest(final PsiMethod method, final Set methodsToPropagateExceptions) throws Exception { PsiClassType newExceptionType = JavaPsiFacade.getElementFactory(getProject()) - .createTypeByFQClassName(JavaClassNames.JAVA_LANG_EXCEPTION, GlobalSearchScope.allScope(getProject())); + .createTypeByFQClassName(CommonClassNames.JAVA_LANG_EXCEPTION, GlobalSearchScope.allScope(getProject())); final ThrownExceptionInfo[] newExceptions = new ThrownExceptionInfo[]{new JavaThrownExceptionInfo(-1, newExceptionType)}; doTest(new ParameterInfoImpl[0], newExceptions, null, methodsToPropagateExceptions, method); } diff --git a/plugin/src/test/java_/com/intellij/refactoring/ChangeSignatureTest.java b/plugin/src/test/java_/com/intellij/refactoring/ChangeSignatureTest.java index dfd2dea09b..c1725a4461 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/ChangeSignatureTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/ChangeSignatureTest.java @@ -15,26 +15,25 @@ */ package com.intellij.refactoring; -import static org.junit.Assert.assertTrue; - -import java.util.HashSet; - -import com.intellij.java.language.psi.*; -import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; - -import jakarta.annotation.Nullable; import com.intellij.JavaTestUtil; import com.intellij.java.impl.refactoring.changeSignature.ChangeSignatureProcessor; import com.intellij.java.impl.refactoring.changeSignature.JavaThrownExceptionInfo; import com.intellij.java.impl.refactoring.changeSignature.ParameterInfoImpl; import com.intellij.java.impl.refactoring.changeSignature.ThrownExceptionInfo; import com.intellij.java.impl.refactoring.util.CanonicalTypes; +import com.intellij.java.language.psi.*; +import consulo.codeInsight.TargetElementUtilEx; +import consulo.java.language.module.util.CommonClassNames.*; +import consulo.language.editor.TargetElementUtil; import consulo.language.util.IncorrectOperationException; import consulo.util.collection.ContainerUtil; -import consulo.language.editor.TargetElementUtil; -import consulo.codeInsight.TargetElementUtilEx; -import consulo.java.language.module.util.JavaClassNames; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; +import org.jetbrains.annotations.NonNls; + +import java.util.HashSet; + +import static org.junit.Assert.assertTrue; /** * @author dsl @@ -279,7 +278,7 @@ public void testVarargs2() throws Exception public void testCovariantReturnType() throws Exception { - doTest(JavaClassNames.JAVA_LANG_RUNNABLE, new ParameterInfoImpl[0], false); + doTest(CommonClassNames.JAVA_LANG_RUNNABLE, new ParameterInfoImpl[0], false); } public void testReorderExceptions() throws Exception @@ -298,7 +297,7 @@ public void testAlreadyHandled() throws Exception public ThrownExceptionInfo[] genExceptions(PsiMethod method) { return new ThrownExceptionInfo[]{ - new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(JavaClassNames.JAVA_LANG_EXCEPTION, method.getResolveScope())) + new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(CommonClassNames.JAVA_LANG_EXCEPTION, method.getResolveScope())) }; } }, false); @@ -312,7 +311,7 @@ public void testConstructorException() throws Exception public ThrownExceptionInfo[] genExceptions(PsiMethod method) { return new ThrownExceptionInfo[]{ - new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(JavaClassNames.JAVA_IO_IO_EXCEPTION, method.getResolveScope())) + new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(CommonClassNames.JAVA_IO_IO_EXCEPTION, method.getResolveScope())) }; } }, false); @@ -326,7 +325,7 @@ public void testAddRuntimeException() throws Exception public ThrownExceptionInfo[] genExceptions(PsiMethod method) { return new ThrownExceptionInfo[]{ - new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(JavaClassNames.JAVA_LANG_RUNTIME_EXCEPTION, method.getResolveScope())) + new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, method.getResolveScope())) }; } }, false); @@ -340,7 +339,7 @@ public void testAddException() throws Exception public ThrownExceptionInfo[] genExceptions(PsiMethod method) { return new ThrownExceptionInfo[]{ - new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(JavaClassNames.JAVA_LANG_EXCEPTION, method.getResolveScope())) + new JavaThrownExceptionInfo(-1, JavaPsiFacade.getInstance(method.getProject()).getElementFactory().createTypeByFQClassName(CommonClassNames.JAVA_LANG_EXCEPTION, method.getResolveScope())) }; } }, false); diff --git a/plugin/src/test/java_/com/intellij/refactoring/CopyClassTest.java b/plugin/src/test/java_/com/intellij/refactoring/CopyClassTest.java index d184a05e3b..192daafbee 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/CopyClassTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/CopyClassTest.java @@ -15,29 +15,29 @@ */ package com.intellij.refactoring; -import java.io.File; -import java.util.Collections; -import java.util.HashMap; - import com.intellij.JavaTestUtil; import com.intellij.codeInsight.CodeInsightTestCase; -import consulo.document.FileDocumentManager; -import consulo.java.language.module.util.JavaClassNames; -import consulo.virtualFileSystem.LocalFileSystem; -import consulo.virtualFileSystem.VirtualFile; +import com.intellij.java.impl.refactoring.copy.CopyClassesHandler; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.JavaPsiFacade; import com.intellij.java.language.psi.PsiClass; -import consulo.language.psi.PsiDirectory; -import consulo.language.psi.PsiElement; -import consulo.language.psi.PsiFile; import com.intellij.java.language.psi.PsiJavaFile; -import consulo.language.codeStyle.PostprocessReformattingAspect; import com.intellij.psi.search.ProjectScope; -import com.intellij.java.impl.refactoring.copy.CopyClassesHandler; import com.intellij.testFramework.IdeaTestUtil; import com.intellij.testFramework.PlatformTestUtil; import com.intellij.testFramework.PsiTestUtil; +import consulo.document.FileDocumentManager; +import consulo.language.codeStyle.PostprocessReformattingAspect; +import consulo.language.psi.PsiDirectory; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.virtualFileSystem.LocalFileSystem; +import consulo.virtualFileSystem.VirtualFile; + +import java.io.File; +import java.util.Collections; +import java.util.HashMap; /** * @author yole @@ -50,7 +50,7 @@ public void testReplaceAllOccurrences() throws Exception { } public void testLibraryClass() throws Exception { // IDEADEV-28791 - doTest(JavaClassNames.JAVA_UTIL_ARRAY_LIST, "Bar"); + doTest(CommonClassNames.JAVA_UTIL_ARRAY_LIST, "Bar"); } private void doTest(final String oldName, final String copyName) throws Exception { diff --git a/plugin/src/test/java_/com/intellij/refactoring/IntroduceConstantTest.java b/plugin/src/test/java_/com/intellij/refactoring/IntroduceConstantTest.java index 0f53091c25..e46bda8144 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/IntroduceConstantTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/IntroduceConstantTest.java @@ -1,25 +1,18 @@ package com.intellij.refactoring; -import jakarta.annotation.Nonnull; - -import org.jetbrains.annotations.NonNls; import com.intellij.JavaTestUtil; -import consulo.codeEditor.Editor; -import consulo.project.Project; -import consulo.java.language.module.util.JavaClassNames; -import com.intellij.java.language.psi.PsiClass; -import consulo.language.psi.PsiElement; -import com.intellij.java.language.psi.PsiExpression; -import com.intellij.java.language.psi.PsiJavaFile; -import com.intellij.java.language.psi.PsiLocalVariable; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiType; -import consulo.language.psi.util.PsiTreeUtil; import com.intellij.java.impl.refactoring.ui.TypeSelectorManagerImpl; +import com.intellij.java.language.psi.*; +import com.intellij.java.language.util.VisibilityUtil; import com.intellij.testFramework.LightCodeInsightTestCase; import com.intellij.testFramework.TestDataPath; -import com.intellij.java.language.util.VisibilityUtil; +import consulo.codeEditor.Editor; +import consulo.language.psi.PsiElement; +import consulo.language.psi.util.PsiTreeUtil; +import consulo.project.Project; +import jakarta.annotation.Nonnull; import junit.framework.Assert; +import org.jetbrains.annotations.NonNls; /** * @author ven @@ -134,7 +127,7 @@ protected String getVisibility() { } public void testResultedType() throws Exception { - checkDefaultType(JavaClassNames.JAVA_LANG_OBJECT); + checkDefaultType(CommonClassNames.JAVA_LANG_OBJECT); } public void testResultedTypeWhenNonLocal() throws Exception { diff --git a/plugin/src/test/java_/com/intellij/refactoring/IntroduceParameterObjectTest.java b/plugin/src/test/java_/com/intellij/refactoring/IntroduceParameterObjectTest.java index 7b3490bf44..70bf302278 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/IntroduceParameterObjectTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/IntroduceParameterObjectTest.java @@ -13,28 +13,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/* - * User: anna - * Date: 20-Aug-2008 - */ package com.intellij.refactoring; import com.intellij.JavaTestUtil; -import com.intellij.java.language.psi.JavaPsiFacade; -import com.intellij.java.language.psi.PsiClass; -import com.intellij.java.language.psi.PsiMethod; -import com.intellij.java.language.psi.PsiParameter; +import com.intellij.java.analysis.impl.refactoring.util.VariableData; +import com.intellij.java.impl.refactoring.introduceparameterobject.IntroduceParameterObjectProcessor; +import com.intellij.java.language.psi.*; +import com.intellij.java.language.util.VisibilityUtil; import consulo.document.FileDocumentManager; +import consulo.ide.impl.idea.util.Function; +import consulo.language.psi.scope.GlobalSearchScope; import consulo.virtualFileSystem.LocalFileSystem; import consulo.virtualFileSystem.VirtualFile; -import consulo.language.psi.scope.GlobalSearchScope; -import com.intellij.java.impl.refactoring.introduceparameterobject.IntroduceParameterObjectProcessor; -import com.intellij.java.analysis.impl.refactoring.util.VariableData; -import consulo.ide.impl.idea.util.Function; -import com.intellij.java.language.util.VisibilityUtil; -import consulo.java.language.module.util.JavaClassNames; +/** + * @author anna + * @since 2008-08-20 + */ public abstract class IntroduceParameterObjectTest extends MultiFileTestCase{ @Override protected String getTestRoot() { @@ -158,7 +153,7 @@ public void testTypeParametersWithChosenSubtype() throws Exception { @Override public VariableData[] fun(PsiMethod psiMethod) { final PsiParameter parameter = psiMethod.getParameterList().getParameters()[0]; - final PsiClass collectionClass = getJavaFacade().findClass(JavaClassNames.JAVA_UTIL_COLLECTION); + final PsiClass collectionClass = getJavaFacade().findClass(CommonClassNames.JAVA_UTIL_COLLECTION); final VariableData variableData = new VariableData(parameter, JavaPsiFacade.getElementFactory(getProject()).createType(collectionClass)); variableData.name = parameter.getName(); diff --git a/plugin/src/test/java_/com/intellij/refactoring/IntroduceVariableTest.java b/plugin/src/test/java_/com/intellij/refactoring/IntroduceVariableTest.java index 7c9a5b327e..e82b3a42bc 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/IntroduceVariableTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/IntroduceVariableTest.java @@ -16,18 +16,18 @@ package com.intellij.refactoring; import com.intellij.JavaTestUtil; -import consulo.codeEditor.Editor; -import consulo.project.Project; -import consulo.java.language.module.util.JavaClassNames; -import consulo.language.psi.PsiElement; -import com.intellij.java.language.psi.PsiExpression; -import com.intellij.java.language.psi.PsiType; -import consulo.language.editor.refactoring.introduce.inplace.OccurrencesChooser; import com.intellij.java.impl.refactoring.introduceVariable.InputValidator; import com.intellij.java.impl.refactoring.introduceVariable.IntroduceVariableBase; import com.intellij.java.impl.refactoring.introduceVariable.IntroduceVariableSettings; import com.intellij.java.impl.refactoring.ui.TypeSelectorManagerImpl; +import com.intellij.java.language.psi.CommonClassNames; +import com.intellij.java.language.psi.PsiExpression; +import com.intellij.java.language.psi.PsiType; import com.intellij.testFramework.LightCodeInsightTestCase; +import consulo.codeEditor.Editor; +import consulo.language.editor.refactoring.introduce.inplace.OccurrencesChooser; +import consulo.language.psi.PsiElement; +import consulo.project.Project; import consulo.util.collection.MultiMap; import jakarta.annotation.Nonnull; import junit.framework.Assert; @@ -55,11 +55,11 @@ public void testInsideFor() throws Exception { } public void testReplaceAll() throws Exception { - doTest(new MockIntroduceVariableHandler("s", true, true, true, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("s", true, true, true, CommonClassNames.JAVA_LANG_STRING)); } public void testIDEADEV3678() throws Exception { - doTest(new MockIntroduceVariableHandler("component", true, true, true, JavaClassNames.JAVA_LANG_OBJECT)); + doTest(new MockIntroduceVariableHandler("component", true, true, true, CommonClassNames.JAVA_LANG_OBJECT)); } public void testIDEADEV13369() throws Exception { @@ -71,7 +71,7 @@ public void testAnonymousClass() throws Exception { } public void testAnonymousClass1() throws Exception { - doTest(new MockIntroduceVariableHandler("runnable", false, false, false, JavaClassNames.JAVA_LANG_RUNNABLE)); + doTest(new MockIntroduceVariableHandler("runnable", false, false, false, CommonClassNames.JAVA_LANG_RUNNABLE)); } public void testAnonymousClass2() throws Exception { @@ -83,7 +83,7 @@ public void testParenthized() throws Exception { } public void testMethodCall() throws Exception { - doTest(new MockIntroduceVariableHandler("temp", true, true, true, JavaClassNames.JAVA_LANG_OBJECT)); + doTest(new MockIntroduceVariableHandler("temp", true, true, true, CommonClassNames.JAVA_LANG_OBJECT)); } public void testMethodCallInSwitch() throws Exception { @@ -95,11 +95,11 @@ public void testParenthizedOccurence() throws Exception { } public void testParenthizedOccurence1() throws Exception { - doTest(new MockIntroduceVariableHandler("s", true, true, true, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("s", true, true, true, CommonClassNames.JAVA_LANG_STRING)); } public void testConflictingField() throws Exception { - doTest(new MockIntroduceVariableHandler("name", true, false, true, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("name", true, false, true, CommonClassNames.JAVA_LANG_STRING)); } public void testConflictingFieldInExpression() throws Exception { @@ -119,15 +119,15 @@ public void testScr16910() throws Exception { } public void testSCR18295() throws Exception { - doTest(new MockIntroduceVariableHandler("it", true, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("it", true, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSCR18295a() throws Exception { - doTest(new MockIntroduceVariableHandler("it", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("it", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testFromInjected() throws Exception { - doTest(new MockIntroduceVariableHandler("regexp", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("regexp", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSCR10412() throws Exception { @@ -135,11 +135,11 @@ public void testSCR10412() throws Exception { } public void testSCR22718() throws Exception { - doTest(new MockIntroduceVariableHandler("object", true, true, false, JavaClassNames.JAVA_LANG_OBJECT)); + doTest(new MockIntroduceVariableHandler("object", true, true, false, CommonClassNames.JAVA_LANG_OBJECT)); } public void testSCR26075() throws Exception { - doTest(new MockIntroduceVariableHandler("wrong", false, false, false, JavaClassNames.JAVA_LANG_STRING) { + doTest(new MockIntroduceVariableHandler("wrong", false, false, false, CommonClassNames.JAVA_LANG_STRING) { @Override protected void assertValidationResult(boolean validationResult) { assertFalse(validationResult); @@ -157,7 +157,7 @@ protected boolean reportConflicts(MultiMap conflicts, final P } public void testConflictingFieldInOuterClass() throws Exception { - doTest(new MockIntroduceVariableHandler("text", true, true, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("text", true, true, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSkipSemicolon() throws Exception { @@ -165,11 +165,11 @@ public void testSkipSemicolon() throws Exception { } public void testInsideIf() throws Exception { - doTest(new MockIntroduceVariableHandler("s1", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("s1", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testInsideElse() throws Exception { - doTest(new MockIntroduceVariableHandler("s1", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("s1", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testInsideWhile() throws Exception { @@ -201,19 +201,19 @@ public void testThisQualifier() throws Exception { } public void testSubLiteral() throws Exception { - doTest(new MockIntroduceVariableHandler("str", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("str", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSubLiteral1() throws Exception { - doTest(new MockIntroduceVariableHandler("str", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("str", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSubLiteralFromExpression() throws Exception { - doTest(new MockIntroduceVariableHandler("str", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("str", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSubExpressionFromIntellijidearulezzz() throws Exception { - doTest(new MockIntroduceVariableHandler("str", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("str", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testSubPrimitiveLiteral() throws Exception { @@ -233,7 +233,7 @@ public void testEnumArrayFromVarargs() throws Exception { } public void testFromFinalFieldOnAssignment() throws Exception { - doTest(new MockIntroduceVariableHandler("strs", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("strs", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testNoArrayFromVarargs() throws Exception { @@ -268,7 +268,7 @@ public void testTypeAnnotations() throws Exception { } public void testReturnStatementWithoutSemicolon() throws Exception { - doTest(new MockIntroduceVariableHandler("b", true, true, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("b", true, true, false, CommonClassNames.JAVA_LANG_STRING)); } public void testAndAndSubexpression() throws Exception { @@ -284,7 +284,7 @@ public void testDuplicatesAnonymousClassCreationWithSimilarParameters () throws } public void testDifferentForeachParameters () throws Exception { - doTest(new MockIntroduceVariableHandler("tostr", true, true, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("tostr", true, true, false, CommonClassNames.JAVA_LANG_STRING)); } public void testCollapsedToDiamond() throws Exception { @@ -296,7 +296,7 @@ public void testCantCollapsedToDiamond() throws Exception { } public void testFromForInitializer() throws Exception { - doTest(new MockIntroduceVariableHandler("list", true, true, true, JavaClassNames.JAVA_UTIL_LIST)); + doTest(new MockIntroduceVariableHandler("list", true, true, true, CommonClassNames.JAVA_UTIL_LIST)); } public void testInvalidPostfixExpr() throws Exception { @@ -362,7 +362,7 @@ protected void showErrorMessage(Project project, Editor editor, String message) public void testIncorrectExpressionSelected() throws Exception { try { - doTest(new MockIntroduceVariableHandler("toString", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("toString", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } catch (Exception e) { assertEquals(e.getMessage(), "Error message:Cannot perform refactoring.\n" + @@ -373,15 +373,15 @@ public void testIncorrectExpressionSelected() throws Exception { } public void testMultiCatchSimple() throws Exception { - doTest(new MockIntroduceVariableHandler("e", true, true, false, JavaClassNames.JAVA_LANG_EXCEPTION, true)); + doTest(new MockIntroduceVariableHandler("e", true, true, false, CommonClassNames.JAVA_LANG_EXCEPTION, true)); } public void testMultiCatchTyped() throws Exception { - doTest(new MockIntroduceVariableHandler("b", true, true, false, JavaClassNames.JAVA_LANG_EXCEPTION, true)); + doTest(new MockIntroduceVariableHandler("b", true, true, false, CommonClassNames.JAVA_LANG_EXCEPTION, true)); } public void testBeforeVoidStatement() throws Exception { - doTest(new MockIntroduceVariableHandler("c", false, false, false, JavaClassNames.JAVA_LANG_OBJECT)); + doTest(new MockIntroduceVariableHandler("c", false, false, false, CommonClassNames.JAVA_LANG_OBJECT)); } public void testLambdaExpr() throws Exception { @@ -397,7 +397,7 @@ public void testLambdaExprNotAccepted() throws Exception { } public void testOneLineLambdaVoidCompatible() throws Exception { - doTest(new MockIntroduceVariableHandler("c", false, false, false, JavaClassNames.JAVA_LANG_STRING)); + doTest(new MockIntroduceVariableHandler("c", false, false, false, CommonClassNames.JAVA_LANG_STRING)); } public void testOneLineLambdaValueCompatible() throws Exception { doTest(new MockIntroduceVariableHandler("c", false, false, false, "int")); diff --git a/plugin/src/test/java_/com/intellij/refactoring/TurnRefsToSuperTest.java b/plugin/src/test/java_/com/intellij/refactoring/TurnRefsToSuperTest.java index 227bd23840..9a3a9ec7b2 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/TurnRefsToSuperTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/TurnRefsToSuperTest.java @@ -15,12 +15,12 @@ */ package com.intellij.refactoring; -import consulo.document.FileDocumentManager; -import consulo.virtualFileSystem.VirtualFile; -import consulo.java.language.module.util.JavaClassNames; +import com.intellij.java.impl.refactoring.turnRefsToSuper.TurnRefsToSuperProcessor; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiClass; +import consulo.document.FileDocumentManager; import consulo.language.psi.scope.GlobalSearchScope; -import com.intellij.java.impl.refactoring.turnRefsToSuper.TurnRefsToSuperProcessor; +import consulo.virtualFileSystem.VirtualFile; import org.jetbrains.annotations.NonNls; public abstract class TurnRefsToSuperTest extends MultiFileTestCase { @@ -37,7 +37,7 @@ public abstract class TurnRefsToSuperTest extends MultiFileTestCase { public void testInstanceOf() throws Exception { doTest("A", "I", false); } public void testFieldTest() throws Exception { doTest("Component1", "IDoSomething", false); } public void testScr34000() throws Exception { doTest("SimpleModel", "Model", false); } - public void testScr34020() throws Exception { doTest(JavaClassNames.JAVA_UTIL_LIST, JavaClassNames.JAVA_UTIL_COLLECTION, false); } + public void testScr34020() throws Exception { doTest(CommonClassNames.JAVA_UTIL_LIST, CommonClassNames.JAVA_UTIL_COLLECTION, false); } public void testCommonInheritor() throws Exception { doTest("Client.V", "Client.L", false); } public void testCommonInheritorFail() throws Exception { doTest("Client.V", "Client.L", false); } public void testCommonInheritorResults() throws Exception { doTest("Client.V", "Client.L", false); } diff --git a/plugin/src/test/java_/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureTest.java b/plugin/src/test/java_/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureTest.java index 37bc22c75e..9e11b59607 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureTest.java @@ -1,21 +1,20 @@ package com.intellij.refactoring.changeClassSignature; -import static org.junit.Assert.assertTrue; - -import consulo.java.language.module.util.JavaClassNames; -import jakarta.annotation.Nonnull; - +import com.intellij.JavaTestUtil; import com.intellij.java.impl.refactoring.changeClassSignature.ChangeClassSignatureProcessor; import com.intellij.java.impl.refactoring.changeClassSignature.TypeParameterInfo; -import org.jetbrains.annotations.NonNls; -import com.intellij.JavaTestUtil; +import com.intellij.java.language.psi.CommonClassNames; import com.intellij.java.language.psi.PsiClass; -import consulo.language.psi.PsiElement; import com.intellij.refactoring.LightRefactoringTestCase; +import consulo.codeInsight.TargetElementUtilEx; +import consulo.language.editor.TargetElementUtil; +import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; import consulo.util.collection.ContainerUtil; -import consulo.language.editor.TargetElementUtil; -import consulo.codeInsight.TargetElementUtilEx; +import jakarta.annotation.Nonnull; +import org.jetbrains.annotations.NonNls; + +import static org.junit.Assert.assertTrue; /** * @author dsl @@ -34,7 +33,7 @@ public void testNoParams() throws Exception { @Override public TypeParameterInfo[] gen(PsiClass aClass) throws IncorrectOperationException { return new TypeParameterInfo[]{ - new TypeParameterInfo(aClass, "T", JavaClassNames.JAVA_LANG_STRING) + new TypeParameterInfo(aClass, "T", CommonClassNames.JAVA_LANG_STRING) }; } }); @@ -45,7 +44,7 @@ public void testInstanceOf() throws Exception { @Override public TypeParameterInfo[] gen(PsiClass aClass) throws IncorrectOperationException { return new TypeParameterInfo[]{ - new TypeParameterInfo(aClass, "T", JavaClassNames.JAVA_LANG_STRING) + new TypeParameterInfo(aClass, "T", CommonClassNames.JAVA_LANG_STRING) }; } }); @@ -98,7 +97,7 @@ public void testAddOneFirst() throws Exception { @Override public TypeParameterInfo[] gen(PsiClass aClass) throws IncorrectOperationException { return new TypeParameterInfo[]{ - new TypeParameterInfo(aClass, "T", JavaClassNames.JAVA_LANG_STRING) + new TypeParameterInfo(aClass, "T", CommonClassNames.JAVA_LANG_STRING) }; } }, "Zero.java", "OneString.java"); diff --git a/plugin/src/test/java_/com/intellij/refactoring/migration/MigrationTest.java b/plugin/src/test/java_/com/intellij/refactoring/migration/MigrationTest.java index fa217884b5..e4df14ad4e 100644 --- a/plugin/src/test/java_/com/intellij/refactoring/migration/MigrationTest.java +++ b/plugin/src/test/java_/com/intellij/refactoring/migration/MigrationTest.java @@ -1,13 +1,13 @@ package com.intellij.refactoring.migration; +import com.intellij.JavaTestUtil; import com.intellij.java.impl.refactoring.migration.MigrationMap; import com.intellij.java.impl.refactoring.migration.MigrationMapEntry; import com.intellij.java.impl.refactoring.migration.MigrationProcessor; +import com.intellij.java.language.psi.CommonClassNames; +import com.intellij.refactoring.MultiFileTestCase; import consulo.document.FileDocumentManager; -import consulo.java.language.module.util.JavaClassNames; import consulo.virtualFileSystem.VirtualFile; -import com.intellij.refactoring.MultiFileTestCase; -import com.intellij.JavaTestUtil; /** * @author dsl @@ -15,7 +15,7 @@ public abstract class MigrationTest extends MultiFileTestCase { public void testUnexistingClassInUnexistingPackage() throws Exception { doTest(createAction(new MigrationMap(new MigrationMapEntry[]{ - new MigrationMapEntry("qqq.aaa.Yahoo", JavaClassNames.JAVA_LANG_STRING, MigrationMapEntry.CLASS, false) + new MigrationMapEntry("qqq.aaa.Yahoo", CommonClassNames.JAVA_LANG_STRING, MigrationMapEntry.CLASS, false) }))); }