MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-18 09:34:34 +07:00
Code Issues Packages Projects Releases Wiki Activity

[java-highlighting] IDEA-339935 JEP 463

Browse Source 
- rename unnamed classes to implicitly declared classes

GitOrigin-RevId: 2c6d7f16a1dc6d2371b8f8b5f5675246c9bc99f9
This commit is contained in:
Mikhail Pyltsin
2023-12-11 15:49:28 +00:00
committed by intellij-monorepo-bot
parent 9e479dc1a2
commit 3f86cf9292
108 changed files with 333 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/debugger/impl/src/com/intellij/debugger/engine/JVMNameUtil.java
+1 -1
View File
@@ -281,7 +281,7 @@ public final class JVMNameUtil {
if (PsiUtil.isLocalOrAnonymousClass(aClass)) {
return null;
}
if (aClass instanceof PsiUnnamedClass a) {
if (aClass instanceof PsiImplicitClass a) {
return ClassUtil.getJVMClassName(a);
}
String name = aClass.getName();
java/execution/impl/src/com/intellij/execution/application/AbstractApplicationConfigurationProducer.java
+2 -2
View File
@@ -59,8 +59,8 @@ public abstract class AbstractApplicationConfigurationProducer<T extends Applica
}
private void setupConfiguration(T configuration, final PsiClass aClass, final ConfigurationContext context) {
if (aClass instanceof PsiUnnamedClass) {
configuration.setUnnamedClassConfiguration(true);
if (aClass instanceof PsiImplicitClass) {
configuration.setImplicitClassConfiguration(true);
}
configuration.setMainClassName(JavaExecutionUtil.getRuntimeQualifiedName(aClass));
configuration.setGeneratedName();
java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java
+5 -5
View File
@@ -34,7 +34,7 @@ import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.impl.java.stubs.index.JavaUnnamedClassIndex;
import com.intellij.psi.impl.java.stubs.index.JavaImplicitClassIndex;
import com.intellij.psi.util.PsiMethodUtil;
import com.intellij.refactoring.listeners.RefactoringElementListener;
import com.intellij.util.PathUtil;
@@ -191,10 +191,10 @@ public class ApplicationConfiguration extends JavaRunConfigurationBase
public JavaRunConfigurationModule checkClass() throws RuntimeConfigurationException {
final JavaRunConfigurationModule configurationModule = getConfigurationModule();
final String mainClass = getMainClassName();
if (getOptions().isUnnamedClassConfiguration()) {
if (getOptions().isImplicitClassConfiguration()) {
if (mainClass != null && !DumbService.isDumb(getProject())) {
try {
final boolean matchingClass = !JavaUnnamedClassIndex.getInstance()
final boolean matchingClass = !JavaImplicitClassIndex.getInstance()
.getElements(mainClass, getProject(), configurationModule.getSearchScope())
.isEmpty();
if (!matchingClass) {
@@ -367,9 +367,9 @@ public class ApplicationConfiguration extends JavaRunConfigurationBase
getOptions().setIncludeProvidedScope(value);
}
public boolean isUnnamedClassConfiguration() { return getOptions().isUnnamedClassConfiguration(); }
public boolean isImplicitClassConfiguration() { return getOptions().isImplicitClassConfiguration(); }
public void setUnnamedClassConfiguration(boolean value) { getOptions().setUnnamedClassConfiguration(value); }
public void setImplicitClassConfiguration(boolean value) { getOptions().setImplicitClassConfiguration(value); }
@Override
public Collection<Module> getValidModules() {
java/execution/impl/src/com/intellij/execution/application/ApplicationRunLineMarkerProvider.java
+1 -2
View File
@@ -22,7 +22,6 @@ import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
public class ApplicationRunLineMarkerProvider extends RunLineMarkerContributor {
private final static Comparator<PsiMethod> mainCandidateComparator = (o1, o2) -> {
boolean isO1Static = o1.hasModifierProperty(PsiModifier.STATIC);
@@ -59,7 +58,7 @@ public class ApplicationRunLineMarkerProvider extends RunLineMarkerContributor {
else if (parent instanceof PsiMethod method) {
if (!"main".equals(method.getName()) || !PsiMethodUtil.isMainMethod(method)) return null;
PsiClass containingClass = method.getContainingClass();
if (!(containingClass instanceof PsiUnnamedClass) && PsiTreeUtil.getParentOfType(containingClass, PsiUnnamedClass.class) != null) return null;
if (!(containingClass instanceof PsiImplicitClass) && PsiTreeUtil.getParentOfType(containingClass, PsiImplicitClass.class) != null) return null;
if (containingClass == null || PsiUtil.isLocalOrAnonymousClass(containingClass)) return null;
if (containingClass.isInterface() && !method.hasModifierProperty(PsiModifier.STATIC)) return null;
Optional<PsiMethod> mainMethod =
java/execution/impl/src/com/intellij/execution/application/JavaApplicationSettingsEditor.java
+34 -34
View File
@@ -31,11 +31,11 @@ import static com.intellij.execution.ui.CommandLinePanel.setMinimumWidth;
public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<ApplicationConfiguration> {
private SettingsEditorFragment<ApplicationConfiguration, MainClassPanel> myMainClassFragment;
private final boolean myInitialIsUnnamedClass;
private final boolean myInitialIsImplicitClass;
public JavaApplicationSettingsEditor(ApplicationConfiguration configuration) {
super(configuration);
myInitialIsUnnamedClass = configuration.isUnnamedClassConfiguration();
myInitialIsImplicitClass = configuration.isImplicitClassConfiguration();
}
@Override
@@ -53,14 +53,14 @@ public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<
configuration -> configuration.getOptions().isIncludeProvidedScope(),
(configuration, value) -> configuration.getOptions().setIncludeProvidedScope(value)));
fragments.add(SettingsEditorFragment.createTag("unnamed.class",
ExecutionBundle.message("application.configuration.is.unnamed.class"),
ExecutionBundle.message("application.configuration.is.implicit.class"),
ExecutionBundle.message("group.java.options"),
configuration -> {
return configuration.isUnnamedClassConfiguration();
return configuration.isImplicitClassConfiguration();
},
(configuration, value) -> {
configuration.setUnnamedClassConfiguration(value);
updateMainClassFragment(configuration.isUnnamedClassConfiguration());
configuration.setImplicitClassConfiguration(value);
updateMainClassFragment(configuration.isImplicitClassConfiguration());
}));
fragments.add(commonParameterFragments.programArguments());
fragments.add(new TargetPathFragment<>());
@@ -75,8 +75,8 @@ public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<
private class MainClassPanel extends JPanel {
private final ClassEditorField myClassEditorField;
private final TextFieldWithAutoCompletion<String> myUnnamedClassField;
private boolean myIsUnnamedClassConfiguration;
private final TextFieldWithAutoCompletion<String> myImplicitClassField;
private boolean myIsImplicitClassConfiguration;
private MainClassPanel(ModuleClasspathCombo classpathCombo) {
super(new GridBagLayout());
@@ -91,33 +91,33 @@ public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<
String placeholder = ExecutionBundle.message("application.configuration.main.class.placeholder");
myClassEditorField.setPlaceholder(placeholder);
myClassEditorField.getAccessibleContext().setAccessibleName(placeholder);
myClassEditorField.setVisible(!myIsUnnamedClassConfiguration);
myClassEditorField.setVisible(!myIsImplicitClassConfiguration);
setMinimumWidth(myClassEditorField, 300);
GridBag constraints = new GridBag().setDefaultFill(GridBagConstraints.HORIZONTAL).setDefaultWeightX(1.0);
add(myClassEditorField, constraints.nextLine());
myUnnamedClassField = new TextFieldWithAutoCompletion<>(getProject(), new StringsCompletionProvider(null, AllIcons.FileTypes.JavaClass) {
myImplicitClassField = new TextFieldWithAutoCompletion<>(getProject(), new StringsCompletionProvider(null, AllIcons.FileTypes.JavaClass) {
@Override
public @NotNull Collection<String> getItems(String prefix, boolean cached, CompletionParameters parameters) {
return DumbService.isDumb(getProject())
? List.of()
: ReadAction.compute(() -> StubIndex.getInstance().getAllKeys(JavaStubIndexKeys.UNNAMED_CLASSES, getProject()));
: ReadAction.compute(() -> StubIndex.getInstance().getAllKeys(JavaStubIndexKeys.IMPLICIT_CLASSES, getProject()));
}
}, true, null);
CommonParameterFragments.setMonospaced(myUnnamedClassField);
String unnamedClassPlaceholder = ExecutionBundle.message("application.configuration.main.unnamed.class.placeholder");
myUnnamedClassField.setVisible(myIsUnnamedClassConfiguration);
myUnnamedClassField.setPlaceholder(unnamedClassPlaceholder);
myUnnamedClassField.getAccessibleContext().setAccessibleName(unnamedClassPlaceholder);
setMinimumWidth(myUnnamedClassField, 300);
add(myUnnamedClassField, constraints.nextLine());
CommonParameterFragments.setMonospaced(myImplicitClassField);
String implicitClassPlaceholder = ExecutionBundle.message("application.configuration.main.unnamed.class.placeholder");
myImplicitClassField.setVisible(myIsImplicitClassConfiguration);
myImplicitClassField.setPlaceholder(implicitClassPlaceholder);
myImplicitClassField.getAccessibleContext().setAccessibleName(implicitClassPlaceholder);
setMinimumWidth(myImplicitClassField, 300);
add(myImplicitClassField, constraints.nextLine());
}
public EditorTextField getEditorTextField() { return myClassEditorField; }
void setClassName(String name) {
if (myIsUnnamedClassConfiguration) {
myUnnamedClassField.setText(name);
if (myIsImplicitClassConfiguration) {
myImplicitClassField.setText(name);
}
else {
myClassEditorField.setClassName(name);
@@ -125,31 +125,31 @@ public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<
}
String getClassName() {
return myIsUnnamedClassConfiguration ? myUnnamedClassField.getText() : myClassEditorField.getClassName();
return myIsImplicitClassConfiguration ? myImplicitClassField.getText() : myClassEditorField.getClassName();
}
boolean isReadyForApply() {
return myIsUnnamedClassConfiguration || myClassEditorField.isReadyForApply();
return myIsImplicitClassConfiguration || myClassEditorField.isReadyForApply();
}
void setUnnamedClassConfiguration(boolean isUnnamedClassConfiguration) {
myIsUnnamedClassConfiguration = isUnnamedClassConfiguration;
void setImplicitClassConfiguration(boolean isImplicitClassConfiguration) {
myIsImplicitClassConfiguration = isImplicitClassConfiguration;
if (myClassEditorField != null) {
myClassEditorField.setVisible(!isUnnamedClassConfiguration);
myUnnamedClassField.setVisible(isUnnamedClassConfiguration);
myClassEditorField.setVisible(!isImplicitClassConfiguration);
myImplicitClassField.setVisible(isImplicitClassConfiguration);
}
}
List<ValidationInfo> getValidation(ApplicationConfiguration configuration) {
return Collections.singletonList(RuntimeConfigurationException.validate(
myIsUnnamedClassConfiguration ? myUnnamedClassField : myClassEditorField,
myIsImplicitClassConfiguration ? myImplicitClassField : myClassEditorField,
() -> { if (!isDefaultSettings()) configuration.checkClass(); }
));
}
JComponent getEditorComponent() {
if (myIsUnnamedClassConfiguration) {
return myUnnamedClassField;
if (myIsImplicitClassConfiguration) {
return myImplicitClassField;
} else {
Editor editor = myClassEditorField.getEditor();
return editor == null ? myClassEditorField : editor.getContentComponent();
@@ -158,7 +158,7 @@ public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<
@Override
public synchronized void addMouseListener(MouseListener l) {
myUnnamedClassField.addMouseListener(l);
myImplicitClassField.addMouseListener(l);
myClassEditorField.addMouseListener(l);
}
}
@@ -179,15 +179,15 @@ public final class JavaApplicationSettingsEditor extends JavaSettingsEditorBase<
myMainClassFragment.setRemovable(false);
myMainClassFragment.setEditorGetter(field -> field.getEditorComponent());
myMainClassFragment.setValidation((configuration) -> mainClassPanel.getValidation(configuration));
updateMainClassFragment(myInitialIsUnnamedClass);
updateMainClassFragment(myInitialIsImplicitClass);
return myMainClassFragment;
}
private void updateMainClassFragment(boolean isUnnamedClass) {
private void updateMainClassFragment(boolean isImplicitClass) {
if (myMainClassFragment == null) return;
myMainClassFragment.component().setUnnamedClassConfiguration(isUnnamedClass);
myMainClassFragment.component().setImplicitClassConfiguration(isImplicitClass);
if (isUnnamedClass) {
if (isImplicitClass) {
myMainClassFragment.setHint(ExecutionBundle.message("application.configuration.main.class.unnamed.hint"));
} else {
myMainClassFragment.setHint(ExecutionBundle.message("application.configuration.main.class.hint"));
java/execution/impl/src/com/intellij/execution/application/JvmMainMethodRunConfigurationOptions.kt
+1 -1
View File
@@ -20,7 +20,7 @@ open class JvmMainMethodRunConfigurationOptions : JvmConfigurationOptions() {
open var isIncludeProvidedScope by property(false)
@get:OptionTag("UNNAMED_CLASS_CONFIGURATION")
open var isUnnamedClassConfiguration by property(false)
open var isImplicitClassConfiguration by property(false)
@get:OptionTag("PASS_PARENT_ENVS")
var isPassParentEnv by property(true)
java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties
+1 -1
View File
@@ -136,7 +136,7 @@ feature.record.patterns.in.for.each=Record patterns in for-each loops
feature.enum.qualified.name.in.switch=Qualified enum as a constant in switch
feature.string.templates=String templates
feature.unnamed.vars=Unnamed patterns and variables
feature.unnamed.classes=Unnamed classes
feature.implicit.classes=Implicitly declared classes
find.searching.for.references.to.class.progress=Searching for references to class {0}...
find.usages.panel.title.derived.classes.cap=Derived classes
java/java-analysis-api/src/com/intellij/codeInsight/intention/QuickFixFactory.java
+2 -2
View File
@@ -518,7 +518,7 @@ public abstract class QuickFixFactory {
/**
* @deprecated error elements are not provided anymore for members declared out of class.
* Now they are members of an unnamed class and can be moved as usual members.
* Now they are members of an implicitly declared class and can be moved as usual members.
*/
@Deprecated
public abstract @NotNull IntentionAction createMoveMemberIntoClassFix(@NotNull PsiErrorElement errorElement);
@@ -640,5 +640,5 @@ public abstract class QuickFixFactory {
@ApiStatus.Experimental
@NotNull
public abstract IntentionAction createAddMainMethodFix(@NotNull PsiUnnamedClass unnamedClass);
public abstract IntentionAction createAddMainMethodFix(@NotNull PsiImplicitClass implicitClass);
}
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
+7 -7
View File
@@ -1350,19 +1350,19 @@ public final class HighlightClassUtil {
return null;
}
static HighlightInfo.Builder checkUnnamedClassMember(@NotNull PsiMember member, @NotNull LanguageLevel languageLevel,
@NotNull PsiFile psiFile) {
if (!(member.getContainingClass() instanceof PsiUnnamedClass unnamedClass)) {
static HighlightInfo.Builder checkImplicitClassMember(@NotNull PsiMember member, @NotNull LanguageLevel languageLevel,
@NotNull PsiFile psiFile) {
if (!(member.getContainingClass() instanceof PsiImplicitClass implicitClass)) {
return null;
}
HighlightInfo.Builder builder = HighlightUtil.checkFeature(member, HighlightingFeature.UNNAMED_CLASSES, languageLevel, psiFile);
HighlightInfo.Builder builder = HighlightUtil.checkFeature(member, HighlightingFeature.IMPLICIT_CLASSES, languageLevel, psiFile);
if (builder == null) return null;
if (!(member instanceof PsiClass) && !HighlightingFeature.UNNAMED_CLASSES.isAvailable(member)) {
boolean hasClassToRelocate = PsiTreeUtil.findChildOfType(unnamedClass, PsiClass.class) != null;
if (!(member instanceof PsiClass) && !HighlightingFeature.IMPLICIT_CLASSES.isAvailable(member)) {
boolean hasClassToRelocate = PsiTreeUtil.findChildOfType(implicitClass, PsiClass.class) != null;
if (hasClassToRelocate) {
MoveMembersIntoClassFix fix = new MoveMembersIntoClassFix(unnamedClass);
MoveMembersIntoClassFix fix = new MoveMembersIntoClassFix(implicitClass);
builder.registerFix(fix, null, null, null, null);
}
}
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUnnamedClassUtil.java → java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightImplicitClassUtil.java
+23 -23
View File
@@ -7,60 +7,60 @@ import com.intellij.codeInsight.daemon.impl.HighlightInfoType;
import com.intellij.codeInsight.intention.QuickFixFactory;
import com.intellij.psi.*;
import com.intellij.psi.util.ClassUtil;
import com.intellij.psi.util.JavaUnnamedClassUtil;
import com.intellij.psi.util.JavaImplicitClassUtil;
import com.intellij.psi.util.PsiMethodUtil;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Checks and reports errors for unnamed classes {@link PsiUnnamedClass}.
* Checks and reports errors for implicitly declared classes {@link PsiImplicitClass}.
*/
public final class HighlightUnnamedClassUtil {
public final class HighlightImplicitClassUtil {
static HighlightInfo.@Nullable Builder checkUnnamedClassHasMainMethod(@NotNull PsiJavaFile file) {
if (!HighlightingFeature.UNNAMED_CLASSES.isAvailable(file)) return null;
PsiUnnamedClass unnamedClass = JavaUnnamedClassUtil.getUnnamedClassFor(file);
if (unnamedClass == null) return null;
PsiMethod[] methods = unnamedClass.getMethods();
static HighlightInfo.@Nullable Builder checkImplicitClassHasMainMethod(@NotNull PsiJavaFile file) {
if (!HighlightingFeature.IMPLICIT_CLASSES.isAvailable(file)) return null;
PsiImplicitClass implicitClass = JavaImplicitClassUtil.getImplicitClassFor(file);
if (implicitClass == null) return null;
PsiMethod[] methods = implicitClass.getMethods();
boolean hasMainMethod = ContainerUtil.exists(methods, method -> "main".equals(method.getName()) && PsiMethodUtil.isMainMethod(method));
if (!hasMainMethod) {
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(file)
.fileLevelAnnotation()
.registerFix(QuickFixFactory.getInstance().createAddMainMethodFix(unnamedClass), null, null, null, null)
.description(JavaErrorBundle.message("error.unnamed.class.contains.no.main.method"));
.registerFix(QuickFixFactory.getInstance().createAddMainMethodFix(implicitClass), null, null, null, null)
.description(JavaErrorBundle.message("error.implicit.class.contains.no.main.method"));
}
return null;
}
static HighlightInfo.@Nullable Builder checkUnnamedClassFileIsValidIdentifier(@NotNull PsiJavaFile file) {
if (!HighlightingFeature.UNNAMED_CLASSES.isAvailable(file)) return null;
PsiUnnamedClass unnamedClass = JavaUnnamedClassUtil.getUnnamedClassFor(file);
if (unnamedClass == null) return null;
String name = ClassUtil.getJVMClassName(unnamedClass);
static HighlightInfo.@Nullable Builder checkImplicitClassFileIsValidIdentifier(@NotNull PsiJavaFile file) {
if (!HighlightingFeature.IMPLICIT_CLASSES.isAvailable(file)) return null;
PsiImplicitClass implicitClass = JavaImplicitClassUtil.getImplicitClassFor(file);
if (implicitClass == null) return null;
String name = ClassUtil.getJVMClassName(implicitClass);
if (!PsiNameHelper.getInstance(file.getProject()).isQualifiedName(name)) {
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(file)
.fileLevelAnnotation()
.description(JavaErrorBundle.message("error.unnamed.class.has.invalid.file.name"));
.description(JavaErrorBundle.message("error.implicit.class.has.invalid.file.name"));
}
return null;
}
static HighlightInfo.@Nullable Builder checkInitializersInUnnamedClass(@NotNull PsiClassInitializer initializer) {
if (initializer.getContainingClass() instanceof PsiUnnamedClass && HighlightingFeature.UNNAMED_CLASSES.isAvailable(initializer)) {
static HighlightInfo.@Nullable Builder checkInitializersInImplicitClass(@NotNull PsiClassInitializer initializer) {
if (initializer.getContainingClass() instanceof PsiImplicitClass && HighlightingFeature.IMPLICIT_CLASSES.isAvailable(initializer)) {
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(initializer).descriptionAndTooltip(
JavaErrorBundle.message("error.initializers.are.not.allowed.in.unnamed.classes"));
JavaErrorBundle.message("error.initializers.are.not.allowed.in.implicit.classes"));
}
return null;
}
static HighlightInfo.@Nullable Builder checkPackageNotAllowedInUnnamedClass(@NotNull PsiPackageStatement statement,
@NotNull PsiFile file) {
if (HighlightingFeature.UNNAMED_CLASSES.isAvailable(file) && JavaUnnamedClassUtil.isFileWithUnnamedClass(file)) {
static HighlightInfo.@Nullable Builder checkPackageNotAllowedInImplicitClass(@NotNull PsiPackageStatement statement,
@NotNull PsiFile file) {
if (HighlightingFeature.IMPLICIT_CLASSES.isAvailable(file) && JavaImplicitClassUtil.isFileWithImplicitClass(file)) {
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(
JavaErrorBundle.message("error.package.statement.not.allowed.for.unnamed.class"));
JavaErrorBundle.message("error.package.statement.not.allowed.for.implicit.class"));
}
return null;
}
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
+7 -7
View File
@@ -373,8 +373,8 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
@Override
public void visitJavaFile(@NotNull PsiJavaFile file) {
super.visitJavaFile(file);
if (!hasErrorResults()) add(HighlightUnnamedClassUtil.checkUnnamedClassHasMainMethod(file));
if (!hasErrorResults()) add(HighlightUnnamedClassUtil.checkUnnamedClassFileIsValidIdentifier(file));
if (!hasErrorResults()) add(HighlightImplicitClassUtil.checkImplicitClassHasMainMethod(file));
if (!hasErrorResults()) add(HighlightImplicitClassUtil.checkImplicitClassFileIsValidIdentifier(file));
}
@Override
@@ -553,14 +553,14 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
@Override
public void visitClassInitializer(@NotNull PsiClassInitializer initializer) {
super.visitClassInitializer(initializer);
if (!hasErrorResults()) add(HighlightClassUtil.checkUnnamedClassMember(initializer, myLanguageLevel, myFile));
if (!hasErrorResults()) add(HighlightClassUtil.checkImplicitClassMember(initializer, myLanguageLevel, myFile));
if (!hasErrorResults()) add(HighlightClassUtil.checkIllegalInstanceMemberInRecord(initializer));
if (!hasErrorResults()) add(HighlightControlFlowUtil.checkInitializerCompleteNormally(initializer));
if (!hasErrorResults()) add(HighlightControlFlowUtil.checkUnreachableStatement(initializer.getBody()));
if (!hasErrorResults()) {
add(HighlightClassUtil.checkThingNotAllowedInInterface(initializer, initializer.getContainingClass()));
}
if (!hasErrorResults()) add(HighlightUnnamedClassUtil.checkInitializersInUnnamedClass(initializer));
if (!hasErrorResults()) add(HighlightImplicitClassUtil.checkInitializersInImplicitClass(initializer));
}
@Override
@@ -724,7 +724,7 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
@Override
public void visitField(@NotNull PsiField field) {
super.visitField(field);
if (!hasErrorResults()) add(HighlightClassUtil.checkUnnamedClassMember(field, myLanguageLevel, myFile));
if (!hasErrorResults()) add(HighlightClassUtil.checkImplicitClassMember(field, myLanguageLevel, myFile));
if (!hasErrorResults()) add(HighlightClassUtil.checkIllegalInstanceMemberInRecord(field));
if (!hasErrorResults()) add(HighlightControlFlowUtil.checkFinalFieldInitialized(field));
}
@@ -989,7 +989,7 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
@Override
public void visitMethod(@NotNull PsiMethod method) {
super.visitMethod(method);
if (!hasErrorResults()) add(HighlightClassUtil.checkUnnamedClassMember(method, myLanguageLevel, myFile));
if (!hasErrorResults()) add(HighlightClassUtil.checkImplicitClassMember(method, myLanguageLevel, myFile));
if (!hasErrorResults()) add(HighlightControlFlowUtil.checkUnreachableStatement(method.getBody()));
if (!hasErrorResults()) add(HighlightMethodUtil.checkConstructorHandleSuperClassExceptions(method));
if (!hasErrorResults()) add(HighlightMethodUtil.checkRecursiveConstructorInvocation(method));
@@ -1147,7 +1147,7 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
if (myLanguageLevel.isAtLeast(LanguageLevel.JDK_1_9)) {
if (!hasErrorResults()) add(ModuleHighlightUtil.checkPackageStatement(statement, myFile, myJavaModule));
}
if (!hasErrorResults()) add(HighlightUnnamedClassUtil.checkPackageNotAllowedInUnnamedClass(statement, myFile));
if (!hasErrorResults()) add(HighlightImplicitClassUtil.checkPackageNotAllowedInImplicitClass(statement, myFile));
}
@Override
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightingFeature.java
+1 -1
View File
@@ -95,7 +95,7 @@ public enum HighlightingFeature {
return super.isSufficient(useSiteLevel) || LanguageLevel.JDK_21_PREVIEW == useSiteLevel;
}
},
UNNAMED_CLASSES(LanguageLevel.JDK_21_PREVIEW, "feature.unnamed.classes");
IMPLICIT_CLASSES(LanguageLevel.JDK_21_PREVIEW, "feature.implicit.classes");
public static final @NonNls String JDK_INTERNAL_PREVIEW_FEATURE = "jdk.internal.PreviewFeature";
public static final @NonNls String JDK_INTERNAL_JAVAC_PREVIEW_FEATURE = "jdk.internal.javac.PreviewFeature";
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/MoveMembersIntoClassFix.java
+7 -7
View File
@@ -13,10 +13,10 @@ import java.util.Arrays;
import java.util.List;
public class MoveMembersIntoClassFix implements ModCommandAction {
private final SmartPsiElementPointer<PsiUnnamedClass> myUnnamedClass;
private final SmartPsiElementPointer<PsiImplicitClass> myImplicitClass;
public MoveMembersIntoClassFix(PsiUnnamedClass unnamedClass) {
myUnnamedClass = SmartPointerManager.createPointer(unnamedClass);
public MoveMembersIntoClassFix(PsiImplicitClass implicitClass) {
myImplicitClass = SmartPointerManager.createPointer(implicitClass);
}
@Override
@@ -31,9 +31,9 @@ public class MoveMembersIntoClassFix implements ModCommandAction {
@Override
public @NotNull ModCommand perform(@NotNull ActionContext context) {
PsiUnnamedClass unnamedClass = myUnnamedClass.getElement();
if (unnamedClass == null) return ModCommand.nop();
PsiClass[] innerClasses = unnamedClass.getInnerClasses();
PsiImplicitClass implicitClass = myImplicitClass.getElement();
if (implicitClass == null) return ModCommand.nop();
PsiClass[] innerClasses = implicitClass.getInnerClasses();
List<? extends ModCommandAction> actionsPerClass = Arrays.stream(innerClasses).map(MoveAllMembersToParticularClassAction::new).toList();
@@ -50,7 +50,7 @@ public class MoveMembersIntoClassFix implements ModCommandAction {
@Override
protected void invoke(@NotNull ActionContext context, @NotNull PsiClass element, @NotNull ModPsiUpdater updater) {
if (!(element.getContainingClass() instanceof PsiUnnamedClass unn)) return;
if (!(element.getContainingClass() instanceof PsiImplicitClass unn)) return;
PsiMember[] members = PsiTreeUtil.getChildrenOfType(unn, PsiMember.class);
if (members == null) return;
List<PsiMember> membersWithoutClasses = Arrays.stream(members).filter(member -> !(member instanceof PsiClass)).toList();
java/java-analysis-impl/src/com/siyeh/ig/psiutils/CodeBlockSurrounder.java
+1 -1
View File
@@ -325,7 +325,7 @@ public abstract class CodeBlockSurrounder {
return null;
}
if (parent instanceof PsiField) {
if (parent.getParent() instanceof PsiUnnamedClass) {
if (parent.getParent() instanceof PsiImplicitClass) {
return null;
}
return new ExtractFieldInitializerSurrounder(expression, (PsiField)parent);
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicFileParser.java
+7 -7
View File
@@ -26,7 +26,7 @@ public class BasicFileParser {
private final BasicJavaParser myParser;
private final AbstractBasicJavaElementTypeFactory.JavaElementTypeContainer myJavaElementTypeContainer;
private final TokenSet UNNAMED_CLASS_INDICATORS;
private final TokenSet IMPLICIT_CLASS_INDICATORS;
private final WhiteSpaceAndCommentSetHolder myWhiteSpaceAndCommentSetHolder = WhiteSpaceAndCommentSetHolder.INSTANCE;
@@ -36,7 +36,7 @@ public class BasicFileParser {
IMPORT_LIST_STOPPER_SET = TokenSet.orSet(
BasicElementTypes.BASIC_MODIFIER_BIT_SET,
TokenSet.create(JavaTokenType.CLASS_KEYWORD, JavaTokenType.INTERFACE_KEYWORD, JavaTokenType.ENUM_KEYWORD, JavaTokenType.AT));
UNNAMED_CLASS_INDICATORS =
IMPLICIT_CLASS_INDICATORS =
TokenSet.create(myJavaElementTypeContainer.METHOD, myJavaElementTypeContainer.FIELD, myJavaElementTypeContainer.CLASS_INITIALIZER);
}
@@ -55,7 +55,7 @@ public class BasicFileParser {
PsiBuilder.Marker firstDeclaration = null;
PsiBuilder.Marker invalidElements = null;
boolean isUnnamedClass = false;
boolean isImplicitClass = false;
while (!builder.eof()) {
if (builder.getTokenType() == JavaTokenType.SEMICOLON) {
builder.advanceLexer();
@@ -75,8 +75,8 @@ public class BasicFileParser {
if (firstDeclaration == null) {
firstDeclaration = declaration;
}
if (!isUnnamedClass && UNNAMED_CLASS_INDICATORS.contains(exprType(declaration))) {
isUnnamedClass = true;
if (!isImplicitClass && IMPLICIT_CLASS_INDICATORS.contains(exprType(declaration))) {
isImplicitClass = true;
}
continue;
}
@@ -96,9 +96,9 @@ public class BasicFileParser {
impListInfo.first.setCustomEdgeTokenBinders(myWhiteSpaceAndCommentSetHolder.getPrecedingCommentBinder(), null); // pass comments behind fake import list
firstDeclaration.setCustomEdgeTokenBinders(myWhiteSpaceAndCommentSetHolder.getSpecialPrecedingCommentBinder(), null);
}
if (isUnnamedClass) {
if (isImplicitClass) {
PsiBuilder.Marker beforeFirst = firstDeclaration.precede();
done(beforeFirst, myJavaElementTypeContainer.UNNAMED_CLASS, myWhiteSpaceAndCommentSetHolder);
done(beforeFirst, myJavaElementTypeContainer.IMPLICIT_CLASS, myWhiteSpaceAndCommentSetHolder);
}
}
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/AbstractBasicJavaElementTypeFactory.java
+3 -3
View File
@@ -59,7 +59,7 @@ public abstract class AbstractBasicJavaElementTypeFactory {
public final IElementType PERMITS_LIST;
public final IElementType CLASS;
public final IElementType UNNAMED_CLASS;
public final IElementType IMPLICIT_CLASS;
public final IElementType ANONYMOUS_CLASS;
@@ -258,7 +258,7 @@ public abstract class AbstractBasicJavaElementTypeFactory {
IElementType RECORD_HEADER,
IElementType PERMITS_LIST,
IElementType CLASS,
IElementType UNNAMED_CLASS,
IElementType IMPLICIT_CLASS,
IElementType ANONYMOUS_CLASS,
IElementType ENUM_CONSTANT_INITIALIZER,
IElementType TYPE_PARAMETER_LIST,
@@ -371,7 +371,7 @@ public abstract class AbstractBasicJavaElementTypeFactory {
this.RECORD_HEADER = RECORD_HEADER;
this.PERMITS_LIST = PERMITS_LIST;
this.CLASS = CLASS;
this.UNNAMED_CLASS = UNNAMED_CLASS;
this.IMPLICIT_CLASS = IMPLICIT_CLASS;
this.ANONYMOUS_CLASS = ANONYMOUS_CLASS;
this.ENUM_CONSTANT_INITIALIZER = ENUM_CONSTANT_INITIALIZER;
this.TYPE_PARAMETER_LIST = TYPE_PARAMETER_LIST;
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java
+1 -1
View File
@@ -32,7 +32,7 @@ import java.util.function.Supplier;
public interface BasicJavaElementType {
IElementType BASIC_CLASS = new IJavaElementType("CLASS");
IElementType BASIC_UNNAMED_CLASS = new IJavaElementType("UNNAMED_CLASS");
IElementType BASIC_IMPLICIT_CLASS = new IJavaElementType("IMPLICIT_CLASS");
IElementType BASIC_ANONYMOUS_CLASS = new IJavaElementType("ANONYMOUS_CLASS");
IElementType BASIC_ENUM_CONSTANT_INITIALIZER = new IJavaElementType("ENUM_CONSTANT_INITIALIZER");
IElementType BASIC_TYPE_PARAMETER_LIST = new IJavaElementType("TYPE_PARAMETER_LIST", true);
java/java-frontback-tests/testSrc/com/intellij/java/parser/declarationParsing/AbstractBasicClassParsingTest.java
+6 -6
View File
@@ -119,22 +119,22 @@ public abstract class AbstractBasicClassParsingTest extends AbstractBasicJavaPar
doTest(true);
}
public void testUnnamedClass0() {
public void testImplicitClass0() {
doTest(true);
}
public void testUnnamedClass1() {
public void testImplicitClass1() {
doTest(true);
}
public void testUnnamedClass2() {
public void testImplicitClass2() {
doTest(true);
}
public void testUnnamedClass3() {
public void testImplicitClass3() {
doTest(true);
}
public void testUnnamedClass4() {
public void testImplicitClass4() {
doTest(true);
}
public void testUnnamedClass5() {
public void testImplicitClass5() {
doTest(true);
}
}
java/java-impl-refactorings/src/com/intellij/refactoring/copy/CopyClassesHandler.java
+2 -2
View File
@@ -603,7 +603,7 @@ public class CopyClassesHandler extends CopyHandlerDelegateBase implements DumbA
element.getParent() != null &&
((PsiClass)element).getContainingClass() == null &&
!(element instanceof PsiAnonymousClass) &&
!(element instanceof PsiUnnamedClass)) {
!(element instanceof PsiImplicitClass)) {
break;
}
element = element.getParent();
@@ -615,7 +615,7 @@ public class CopyClassesHandler extends CopyHandlerDelegateBase implements DumbA
if (isSynthetic(aClass)) {
return null;
}
if (aClass instanceof PsiUnnamedClass) {
if (aClass instanceof PsiImplicitClass) {
return null;
}
buffer.add(aClass);
java/java-impl-refactorings/src/com/intellij/refactoring/extractInterface/ExtractInterfaceHandler.java
+6 -3
View File
@@ -29,7 +29,10 @@ import com.intellij.util.containers.MultiMap;
import org.jetbrains.annotations.Nls;
import org.jetbrains.annotations.NotNull;
import java.util.*;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class ExtractInterfaceHandler implements ElementsHandler, ContextAwareActionHandler {
@@ -71,8 +74,8 @@ public class ExtractInterfaceHandler implements ElementsHandler, ContextAwareAct
return;
}
if (myClass instanceof PsiUnnamedClass) {
String message = RefactoringBundle.message("error.interface.cannot.be.extracted.from.unnamed.class");
if (myClass instanceof PsiImplicitClass) {
String message = RefactoringBundle.message("error.interface.cannot.be.extracted.from.implicit.class");
CommonRefactoringUtil.showErrorHint(project, null, message, getRefactoringName(), HelpID.EXTRACT_INTERFACE);
return;
}
java/java-impl-refactorings/src/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java
+2 -2
View File
@@ -70,8 +70,8 @@ public class ExtractSuperclassHandler implements ElementsHandler, ExtractSupercl
return;
}
if (mySubclass instanceof PsiUnnamedClass) {
String message = RefactoringBundle.message("error.superclass.cannot.be.extracted.from.unnamed.class");
if (mySubclass instanceof PsiImplicitClass) {
String message = RefactoringBundle.message("error.superclass.cannot.be.extracted.from.implicit.class");
CommonRefactoringUtil.showErrorHint(project, null, message, getRefactoringName(), HelpID.EXTRACT_SUPERCLASS);
return;
}
java/java-impl-refactorings/src/com/intellij/refactoring/extractclass/ExtractClassHandler.java
+2 -2
View File
@@ -78,8 +78,8 @@ public class ExtractClassHandler implements ElementsHandler, ContextAwareActionH
if (!containingClass.getManager().isInProject(containingClass)) {
return RefactorJBundle.message("the.selected.class.should.belong.to.project.sources");
}
if (containingClass instanceof PsiUnnamedClass) {
return RefactorJBundle.message("refactoring.cannot.be.done.in.unnamed.class");
if (containingClass instanceof PsiImplicitClass) {
return RefactorJBundle.message("refactoring.cannot.be.done.in.implicit.class");
}
return null;
}
java/java-impl-refactorings/src/com/intellij/refactoring/inline/InlineMethodProcessor.java
+1 -1
View File
@@ -797,7 +797,7 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor {
@Nullable
private PsiLocalVariable declareThis(PsiSubstitutor callSubstitutor, PsiCodeBlock block) {
PsiClass containingClass = myMethod.getContainingClass();
if (myMethod.hasModifierProperty(PsiModifier.STATIC) || containingClass == null || containingClass instanceof PsiUnnamedClass) return null;
if (myMethod.hasModifierProperty(PsiModifier.STATIC) || containingClass == null || containingClass instanceof PsiImplicitClass) return null;
PsiType thisType = GenericsUtil.getVariableTypeByExpressionType(myFactory.createType(containingClass, callSubstitutor));
String thisVarName = new VariableNameGenerator(myMethod.getFirstChild(), VariableKind.LOCAL_VARIABLE)
.byType(thisType).byName("self").generate(true);
java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionContributor.java
+1 -1
View File
@@ -1297,7 +1297,7 @@ public final class JavaCompletionContributor extends CompletionContributor imple
if (PsiUtilCore.getElementType(at) == JavaTokenType.LPARENTH &&
PsiTreeUtil.getParentOfType(ref, PsiExpression.class, PsiClass.class) == null &&
PsiTreeUtil.getParentOfType(at, PsiUnnamedClass.class) == null) { // TODO check before it that there is record
PsiTreeUtil.getParentOfType(at, PsiImplicitClass.class) == null) { // TODO check before it that there is record
// looks like a method declaration, e.g. StringBui<caret>methodName() inside a class
return true;
}
java/java-impl/src/com/intellij/codeInsight/intention/impl/AddMainMethodFix.java
+4 -4
View File
@@ -6,13 +6,13 @@ import com.intellij.modcommand.ActionContext;
import com.intellij.modcommand.ModPsiUpdater;
import com.intellij.modcommand.PsiUpdateModCommandAction;
import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiImplicitClass;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiTypes;
import com.intellij.psi.PsiUnnamedClass;
import org.jetbrains.annotations.NotNull;
public class AddMainMethodFix extends PsiUpdateModCommandAction<PsiUnnamedClass> {
public AddMainMethodFix(@NotNull PsiUnnamedClass element) {
public class AddMainMethodFix extends PsiUpdateModCommandAction<PsiImplicitClass> {
public AddMainMethodFix(@NotNull PsiImplicitClass element) {
super(element);
}
@@ -22,7 +22,7 @@ public class AddMainMethodFix extends PsiUpdateModCommandAction<PsiUnnamedClass>
}
@Override
protected void invoke(@NotNull ActionContext context, @NotNull PsiUnnamedClass element, @NotNull ModPsiUpdater updater) {
protected void invoke(@NotNull ActionContext context, @NotNull PsiImplicitClass element, @NotNull ModPsiUpdater updater) {
PsiMethod mainMethod = JavaPsiFacade.getInstance(context.project()).getElementFactory().createMethod("main", PsiTypes.voidType());
element.add(mainMethod);
}
java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java
+2 -2
View File
@@ -1225,7 +1225,7 @@ public final class QuickFixFactoryImpl extends QuickFixFactory {
}
@Override
public @NotNull IntentionAction createAddMainMethodFix(@NotNull PsiUnnamedClass unnamedClass) {
return new AddMainMethodFix(unnamedClass).asIntention();
public @NotNull IntentionAction createAddMainMethodFix(@NotNull PsiImplicitClass implicitClass) {
return new AddMainMethodFix(implicitClass).asIntention();
}
}
java/java-impl/src/com/intellij/ide/projectView/impl/ClassesTreeStructureProvider.java
+4 -5
View File
@@ -20,7 +20,7 @@ import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiImplUtil;
import com.intellij.psi.util.ClassUtil;
import com.intellij.psi.util.JavaUnnamedClassUtil;
import com.intellij.psi.util.JavaImplicitClassUtil;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -170,10 +170,9 @@ public class ClassesTreeStructureProvider implements SelectableTreeStructureProv
PsiFile value = getValue();
if (value instanceof PsiClassOwner) {
ViewSettings settings = getSettings();
PsiUnnamedClass unnamedClass = JavaUnnamedClassUtil.getUnnamedClassFor(value);
if (unnamedClass != null) {
result.addAll(ClassTreeNode.computeChildren(unnamedClass, settings, myProject, true));
PsiImplicitClass implicitClass = JavaImplicitClassUtil.getImplicitClassFor(value);
if (implicitClass != null) {
result.addAll(ClassTreeNode.computeChildren(implicitClass, settings, myProject, true));
} else {
for (PsiClass aClass : ((PsiClassOwner)value).getClasses()) {
if (!(aClass instanceof SyntheticElement)) {
java/java-impl/src/com/intellij/psi/formatter/java/AbstractJavaBlock.java
+2 -2
View File
@@ -186,7 +186,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo
return new PartialWhitespaceBlock(child, range, wrap, alignment, actualIndent, settings, javaSettings, myFormattingMode);
}
if (childPsi instanceof PsiUnnamedClass) {
if (childPsi instanceof PsiImplicitClass) {
return new SimpleJavaBlock(child, wrap, alignmentStrategy, Indent.getNoneIndent(), settings, javaSettings, formattingMode);
}
if (childPsi instanceof PsiClass || childPsi instanceof PsiJavaModule) {
@@ -370,7 +370,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo
if (parentType == JavaElementType.IMPORT_LIST) return Indent.getNoneIndent();
if (parentType == JavaElementType.FIELD) return Indent.getContinuationWithoutFirstIndent(indentOptions.USE_RELATIVE_INDENTS);
if (parentType == JavaElementType.EXPRESSION_STATEMENT) return Indent.getNoneIndent();
if (parentType == JavaElementType.UNNAMED_CLASS) return Indent.getNoneIndent();
if (parentType == JavaElementType.IMPLICIT_CLASS) return Indent.getNoneIndent();
if (SourceTreeToPsiMap.treeElementToPsi(parent) instanceof PsiFile) {
return Indent.getNoneIndent();
}
java/java-impl/src/com/intellij/refactoring/IntroduceVariableUtil.java
+2 -2
View File
@@ -289,8 +289,8 @@ public final class IntroduceVariableUtil {
}
}
}
if (topLevelExpression.getParent() instanceof PsiField f && f.getParent() instanceof PsiUnnamedClass) {
return JavaRefactoringBundle.message("introduce.variable.message.cannot.extract.in.unnamed.class");
if (topLevelExpression.getParent() instanceof PsiField f && f.getParent() instanceof PsiImplicitClass) {
return JavaRefactoringBundle.message("introduce.variable.message.cannot.extract.in.implicit.class");
}
}
return null;
java/java-impl/src/com/intellij/usageView/JavaUsageViewDescriptionProvider.java
+2 -2
View File
@@ -34,8 +34,8 @@ public class JavaUsageViewDescriptionProvider implements ElementDescriptionProvi
boolean isStatic = initializer.hasModifierProperty(PsiModifier.STATIC);
return isStatic ? CLINIT : INIT;
}
else if (element instanceof PsiUnnamedClass unnamedClass) {
return unnamedClass.getContainingFile().getName();
else if (element instanceof PsiImplicitClass implicitClass) {
return implicitClass.getContainingFile().getName();
}
}
java/java-impl/src/com/siyeh/ig/naming/ConfusingMainMethodInspection.java
+2 -2
View File
@@ -16,9 +16,9 @@
package com.siyeh.ig.naming;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiImplicitClass;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifier;
import com.intellij.psi.PsiUnnamedClass;
import com.intellij.psi.util.PsiMethodUtil;
import com.siyeh.HardcodedMethodConstants;
import com.siyeh.InspectionGadgetsBundle;
@@ -68,7 +68,7 @@ public class ConfusingMainMethodInspection extends BaseInspection {
return;
}
PsiClass containingClass = method.getContainingClass();
if (!(containingClass instanceof PsiUnnamedClass) && containingClass != null && containingClass.getQualifiedName() == null) {
if (!(containingClass instanceof PsiImplicitClass) && containingClass != null && containingClass.getQualifiedName() == null) {
registerMethodError(method, Boolean.TRUE); // main method not runnable
}
}
java/java-impl/src/messages/RefactorJBundle.properties
+1 -1
View File
@@ -18,7 +18,7 @@ the.selected.class.is.an.annotation.type=The selected class is an annotation int
the.refactoring.is.not.supported.on.non.static.inner.classes=The refactoring is not supported on non-static inner classes.
the.selected.class.has.no.members.to.extract=The selected class has no members to extract.
the.selected.class.should.belong.to.project.sources=The selected class should belong to project sources
refactoring.cannot.be.done.in.unnamed.class=Refactoring cannot be done in unnamed class
refactoring.cannot.be.done.in.implicit.class=Refactoring cannot be done in implicitly declared class
references.to.extract=References to extract ( {0, choice, 0#(Not found)|1#{0} reference|2#{0} references}{1, choice, 0#|1# in {1} file|2# in {1} files})
extract.class.as.enum.column.title=As Enum
extract.class.depends.on.0.from.1.tooltip=Depends on {0} from {1}
java/java-indexing-impl/src/META-INF/JavaIndexingPlugin.xml
+1 -1
View File
@@ -48,7 +48,7 @@
<stubIndex implementation="com.intellij.psi.impl.java.stubs.index.JavaFieldNameIndex"/>
<stubIndex implementation="com.intellij.psi.impl.java.stubs.index.JavaAnonymousClassBaseRefOccurenceIndex"/>
<stubIndex implementation="com.intellij.psi.impl.java.stubs.index.JavaAnnotationIndex"/>
<stubIndex implementation="com.intellij.psi.impl.java.stubs.index.JavaUnnamedClassIndex"/>
<stubIndex implementation="com.intellij.psi.impl.java.stubs.index.JavaImplicitClassIndex"/>
<java.shortNamesCache implementation="com.intellij.psi.impl.PsiShortNamesCacheImpl"/>
<java.staticMethodNamesCache implementation="com.intellij.psi.impl.JavaStaticMethodNameCacheImpl" order="first"/>
<projectService serviceInterface="com.intellij.psi.search.PsiShortNamesCache"
java/java-indexing-impl/src/com/intellij/psi/impl/java/stubs/index/JavaImplicitClassIndex.java
+36
View File
@@ -0,0 +1,36 @@
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.psi.impl.java.stubs.index;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiImplicitClass;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.stubs.StringStubIndexExtension;
import com.intellij.psi.stubs.StubIndex;
import com.intellij.psi.stubs.StubIndexKey;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
public class JavaImplicitClassIndex extends StringStubIndexExtension<PsiImplicitClass> {
private static final JavaImplicitClassIndex ourInstance = new JavaImplicitClassIndex();
public static JavaImplicitClassIndex getInstance() {
return ourInstance;
}
@Override
public @NotNull StubIndexKey<String, PsiImplicitClass> getKey() {
return JavaStubIndexKeys.IMPLICIT_CLASSES;
}
public Collection<String> getAllClasses(@NotNull Project project) {
return StubIndex.getInstance().getAllKeys(getKey(), project);
}
public @NotNull Collection<PsiImplicitClass> getElements(@NotNull String key,
@NotNull Project project,
@Nullable GlobalSearchScope scope) {
return StubIndex.getElements(JavaStubIndexKeys.IMPLICIT_CLASSES, key, project, scope, PsiImplicitClass.class);
}
}
java/java-indexing-impl/src/com/intellij/psi/impl/java/stubs/index/JavaUnnamedClassIndex.java
-34
View File
@@ -1,34 +0,0 @@
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.psi.impl.java.stubs.index;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiUnnamedClass;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.stubs.StringStubIndexExtension;
import com.intellij.psi.stubs.StubIndex;
import com.intellij.psi.stubs.StubIndexKey;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
public class JavaUnnamedClassIndex extends StringStubIndexExtension<PsiUnnamedClass> {
private static final JavaUnnamedClassIndex ourInstance = new JavaUnnamedClassIndex();
public static JavaUnnamedClassIndex getInstance() {
return ourInstance;
}
@Override
public @NotNull StubIndexKey<String, PsiUnnamedClass> getKey() {
return JavaStubIndexKeys.UNNAMED_CLASSES;
}
public Collection<String> getAllClasses(@NotNull Project project) {
return StubIndex.getInstance().getAllKeys(getKey(), project);
}
public @NotNull Collection<PsiUnnamedClass> getElements(@NotNull String key, @NotNull Project project, @Nullable GlobalSearchScope scope) {
return StubIndex.getElements(JavaStubIndexKeys.UNNAMED_CLASSES, key, project, scope, PsiUnnamedClass.class);
}
}
java/java-psi-api/src/com/intellij/psi/JavaElementVisitor.java
+4 -4
View File
@@ -185,6 +185,10 @@ public abstract class JavaElementVisitor extends PsiElementVisitor {
visitStatement(statement);
}
public void visitImplicitClass(@NotNull PsiImplicitClass aClass) {
visitClass(aClass);
}
public void visitImplicitVariable(@NotNull ImplicitVariable variable) {
visitLocalVariable(variable);
}
@@ -480,10 +484,6 @@ public abstract class JavaElementVisitor extends PsiElementVisitor {
visitExpression(expression);
}
public void visitUnnamedClass(@NotNull PsiUnnamedClass aClass) {
visitClass(aClass);
}
public void visitUnnamedPattern(@NotNull PsiUnnamedPattern pattern) {
visitPattern(pattern);
}
java/java-psi-api/src/com/intellij/psi/PsiUnnamedClass.java → java/java-psi-api/src/com/intellij/psi/PsiImplicitClass.java
+3 -3
View File
@@ -6,12 +6,12 @@ import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.Nullable;
/**
* Represents unnamed class from <a href="https://openjdk.org/jeps/445">JEP 445</a>.
* Represents implicitly declared class from <a href="https://openjdk.org/jeps/463">JEP 463</a>.
* Please note that it allows a bit more flexibility than the specification itself (e.g., it is allowed not to have the "main" method,
* but have at least one member to be considered an unnamed class)
* but have at least one member to be considered an implicitly declared class)
*/
@ApiStatus.Experimental
public interface PsiUnnamedClass extends PsiClass {
public interface PsiImplicitClass extends PsiClass {
@Override
@Nullable String getQualifiedName();
java/java-psi-api/src/com/intellij/psi/impl/java/stubs/index/JavaStubIndexKeys.java
+1 -1
View File
@@ -16,7 +16,7 @@ public final class JavaStubIndexKeys {
public static final StubIndexKey<String, PsiClass> CLASS_SHORT_NAMES = StubIndexKey.createIndexKey("java.class.shortname");
public static final StubIndexKey<CharSequence, PsiClass> CLASS_FQN = StubIndexKey.createIndexKey("java.class.fqn");
public static final StubIndexKey<String, PsiJavaModule> MODULE_NAMES = StubIndexKey.createIndexKey("java.module.name");
public static final StubIndexKey<String, PsiUnnamedClass> UNNAMED_CLASSES = StubIndexKey.createIndexKey("java.unnamed.class");
public static final StubIndexKey<String, PsiImplicitClass> IMPLICIT_CLASSES = StubIndexKey.createIndexKey("java.unnamed.class"); //preserve old name for index
private JavaStubIndexKeys() { }
}
java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaClassElementType.java
+11 -11
View File
@@ -14,13 +14,13 @@ import com.intellij.psi.impl.java.stubs.index.JavaStubIndexKeys;
import com.intellij.psi.impl.source.PsiAnonymousClassImpl;
import com.intellij.psi.impl.source.PsiClassImpl;
import com.intellij.psi.impl.source.PsiEnumConstantInitializerImpl;
import com.intellij.psi.impl.source.PsiUnnamedClassImpl;
import com.intellij.psi.impl.source.PsiImplicitClassImpl;
import com.intellij.psi.impl.source.tree.JavaDocElementType;
import com.intellij.psi.impl.source.tree.JavaElementType;
import com.intellij.psi.impl.source.tree.LightTreeUtil;
import com.intellij.psi.impl.source.tree.java.AnonymousClassElement;
import com.intellij.psi.impl.source.tree.java.EnumConstantInitializerElement;
import com.intellij.psi.impl.source.tree.java.UnnamedClassElement;
import com.intellij.psi.impl.source.tree.java.ImplicitClassElement;
import com.intellij.psi.stubs.IndexSink;
import com.intellij.psi.stubs.StubElement;
import com.intellij.psi.stubs.StubInputStream;
@@ -48,8 +48,8 @@ public abstract class JavaClassElementType extends JavaStubElementType<PsiClassS
if (node instanceof AnonymousClassElement) {
return new PsiAnonymousClassImpl(node);
}
if (node instanceof UnnamedClassElement) {
return new PsiUnnamedClassImpl(node);
if (node instanceof ImplicitClassElement) {
return new PsiImplicitClassImpl(node);
}
return new PsiClassImpl(node);
@@ -138,18 +138,18 @@ public abstract class JavaClassElementType extends JavaStubElementType<PsiClassS
}
boolean isUnnamed = node.getTokenType() == JavaElementType.UNNAMED_CLASS;
boolean isImplicit = node.getTokenType() == JavaElementType.IMPLICIT_CLASS;
final short flags = PsiClassStubImpl.packFlags(isDeprecatedByComment, isInterface, isEnum, isEnumConst, isAnonymous, isAnnotation,
isInQualifiedNew, hasDeprecatedAnnotation, false, false, hasDocComment, isRecord, isUnnamed);
final JavaClassElementType type = typeForClass(isAnonymous, isEnumConst, isUnnamed);
isInQualifiedNew, hasDeprecatedAnnotation, false, false, hasDocComment, isRecord, isImplicit);
final JavaClassElementType type = typeForClass(isAnonymous, isEnumConst, isImplicit);
return new PsiClassStubImpl<>(type, parentStub, qualifiedName, name, baseRef, flags);
}
@NotNull
private static JavaClassElementType typeForClass(final boolean anonymous, final boolean enumConst, final boolean unnamedClass) {
private static JavaClassElementType typeForClass(final boolean anonymous, final boolean enumConst, final boolean implicitClass) {
return enumConst
? JavaStubElementTypes.ENUM_CONSTANT_INITIALIZER
: unnamedClass ? JavaStubElementTypes.UNNAMED_CLASS
: implicitClass ? JavaStubElementTypes.IMPLICIT_CLASS
: anonymous ? JavaStubElementTypes.ANONYMOUS_CLASS : JavaStubElementTypes.CLASS;
}
@@ -174,8 +174,8 @@ public abstract class JavaClassElementType extends JavaStubElementType<PsiClassS
short flags = dataStream.readShort();
boolean isAnonymous = PsiClassStubImpl.isAnonymous(flags);
boolean isEnumConst = PsiClassStubImpl.isEnumConstInitializer(flags);
boolean isUnnamed = PsiClassStubImpl.isUnnamed(flags);
JavaClassElementType type = typeForClass(isAnonymous, isEnumConst, isUnnamed);
boolean isImplicit = PsiClassStubImpl.isImplicit(flags);
JavaClassElementType type = typeForClass(isAnonymous, isEnumConst, isImplicit);
if (!isAnonymous) {
String name = dataStream.readNameString();
java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaStubElementTypes.java
+4 -4
View File
@@ -12,7 +12,7 @@ import com.intellij.psi.stubs.IndexSink;
import com.intellij.psi.stubs.StubBase;
import com.intellij.psi.stubs.StubElement;
import com.intellij.psi.tree.IStubFileElementType;
import com.intellij.psi.util.JavaUnnamedClassUtil;
import com.intellij.psi.util.JavaImplicitClassUtil;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
@@ -50,18 +50,18 @@ public interface JavaStubElementTypes {
}
};
JavaClassElementType UNNAMED_CLASS = new JavaClassElementType("UNNAMED_CLASS", BasicJavaElementType.BASIC_UNNAMED_CLASS) {
JavaClassElementType IMPLICIT_CLASS = new JavaClassElementType("IMPLICIT_CLASS", BasicJavaElementType.BASIC_IMPLICIT_CLASS) {
@NotNull
@Override
public ASTNode createCompositeNode() {
return new UnnamedClassElement();
return new ImplicitClassElement();
}
@Override
public void indexStub(@NotNull PsiClassStub stub, @NotNull IndexSink sink) {
StubElement parent = stub.getParentStub();
if (parent instanceof PsiJavaFileStub) {
sink.occurrence(JavaStubIndexKeys.UNNAMED_CLASSES, JavaUnnamedClassUtil.getJvmName(((PsiJavaFileStub)parent).getPsi().getName()));
sink.occurrence(JavaStubIndexKeys.IMPLICIT_CLASSES, JavaImplicitClassUtil.getJvmName(((PsiJavaFileStub)parent).getPsi().getName()));
}
}
};
java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/PsiClassStub.java
+1 -1
View File
@@ -19,7 +19,7 @@ public interface PsiClassStub<T extends PsiClass> extends PsiMemberStub<T> {
return false;
}
default boolean isUnnamed() {
default boolean isImplicit() {
return false;
}
java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/SourceStubPsiFactory.java
+1 -1
View File
@@ -12,7 +12,7 @@ public class SourceStubPsiFactory extends StubPsiFactory {
public PsiClass createClass(PsiClassStub stub) {
if (stub.isEnumConstantInitializer()) return new PsiEnumConstantInitializerImpl(stub);
if (stub.isAnonymous()) return new PsiAnonymousClassImpl(stub);
if (stub.isUnnamed()) return new PsiUnnamedClassImpl(stub);
if (stub.isImplicit()) return new PsiImplicitClassImpl(stub);
return new PsiClassImpl(stub);
}
java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiClassStubImpl.java
+7 -7
View File
@@ -26,7 +26,7 @@ public class PsiClassStubImpl<T extends PsiClass> extends StubBase<T> implements
private static final int LOCAL_CLASS_INNER = 0x200;
private static final int HAS_DOC_COMMENT = 0x400;
private static final int RECORD = 0x800;
private static final int UNNAMED = 0x1000;
private static final int IMPLICIT = 0x1000;
private final @NotNull TypeInfo myTypeInfo;
private final String myQualifiedName;
@@ -107,8 +107,8 @@ public class PsiClassStubImpl<T extends PsiClass> extends StubBase<T> implements
}
@Override
public boolean isUnnamed() {
return BitUtil.isSet(myFlags, UNNAMED);
public boolean isImplicit() {
return BitUtil.isSet(myFlags, IMPLICIT);
}
@Override
@@ -120,8 +120,8 @@ public class PsiClassStubImpl<T extends PsiClass> extends StubBase<T> implements
return BitUtil.isSet(flags, ENUM_CONSTANT_INITIALIZER);
}
public static boolean isUnnamed(final short flags) {
return BitUtil.isSet(flags, UNNAMED);
public static boolean isImplicit(final short flags) {
return BitUtil.isSet(flags, IMPLICIT);
}
@Override
@@ -199,7 +199,7 @@ public class PsiClassStubImpl<T extends PsiClass> extends StubBase<T> implements
boolean localClassInner,
boolean hasDocComment,
boolean isRecord,
boolean isUnnamed) {
boolean isImplicit) {
short flags = 0;
if (isDeprecated) flags |= DEPRECATED;
if (isInterface) flags |= INTERFACE;
@@ -213,7 +213,7 @@ public class PsiClassStubImpl<T extends PsiClass> extends StubBase<T> implements
if (localClassInner) flags |= LOCAL_CLASS_INNER;
if (hasDocComment) flags |= HAS_DOC_COMMENT;
if (isRecord) flags |= RECORD;
if (isUnnamed) flags |= UNNAMED;
if (isImplicit) flags |= IMPLICIT;
return flags;
}
java/java-psi-impl/src/com/intellij/psi/impl/source/Constants.java
+1 -1
View File
@@ -20,7 +20,7 @@ import com.intellij.psi.impl.source.tree.JavaElementType;
import com.intellij.psi.tree.TokenSet;
public interface Constants extends ElementType {
TokenSet CLASS_BIT_SET = TokenSet.create(JavaElementType.CLASS, JavaElementType.ANONYMOUS_CLASS, JavaElementType.ENUM_CONSTANT_INITIALIZER, JavaElementType.UNNAMED_CLASS);
TokenSet CLASS_BIT_SET = TokenSet.create(JavaElementType.CLASS, JavaElementType.ANONYMOUS_CLASS, JavaElementType.ENUM_CONSTANT_INITIALIZER, JavaElementType.IMPLICIT_CLASS);
TokenSet FIELD_BIT_SET = TokenSet.create(JavaElementType.FIELD, JavaElementType.ENUM_CONSTANT);
TokenSet METHOD_BIT_SET = TokenSet.create(JavaElementType.METHOD, JavaElementType.ANNOTATION_METHOD);
TokenSet CLASS_INITIALIZER_BIT_SET = TokenSet.create(JavaElementType.CLASS_INITIALIZER);
java/java-psi-impl/src/com/intellij/psi/impl/source/PsiUnnamedClassImpl.java → java/java-psi-impl/src/com/intellij/psi/impl/source/PsiImplicitClassImpl.java
+9 -9
View File
@@ -17,7 +17,7 @@ import com.intellij.psi.scope.PsiScopeProcessor;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.LocalSearchScope;
import com.intellij.psi.search.SearchScope;
import com.intellij.psi.util.JavaUnnamedClassUtil;
import com.intellij.psi.util.JavaImplicitClassUtil;
import com.intellij.psi.util.PsiUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
@@ -28,14 +28,14 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class PsiUnnamedClassImpl extends JavaStubPsiElement<PsiClassStub<?>> implements PsiUnnamedClass, PsiExtensibleClass {
public class PsiImplicitClassImpl extends JavaStubPsiElement<PsiClassStub<?>> implements PsiImplicitClass, PsiExtensibleClass {
private final ClassInnerStuffCache myInnersCache = new ClassInnerStuffCache(this);
public PsiUnnamedClassImpl(@NotNull PsiClassStub<?> stub) {
super(stub, JavaStubElementTypes.UNNAMED_CLASS);
public PsiImplicitClassImpl(@NotNull PsiClassStub<?> stub) {
super(stub, JavaStubElementTypes.IMPLICIT_CLASS);
}
public PsiUnnamedClassImpl(@NotNull ASTNode node) {
public PsiImplicitClassImpl(@NotNull ASTNode node) {
super(node);
}
@@ -43,7 +43,7 @@ public class PsiUnnamedClassImpl extends JavaStubPsiElement<PsiClassStub<?>> imp
public @Nullable String getQualifiedName() {
PsiElement parent = getParent();
if (parent instanceof PsiJavaFile) {
return JavaUnnamedClassUtil.getJvmName(((PsiJavaFile)parent).getName());
return JavaImplicitClassUtil.getJvmName(((PsiJavaFile)parent).getName());
}
return null;
}
@@ -223,7 +223,7 @@ public class PsiUnnamedClassImpl extends JavaStubPsiElement<PsiClassStub<?>> imp
@Override
public PsiElement setName(@NotNull String name) throws IncorrectOperationException {
throw new IncorrectOperationException("Unnamed class may have no name");
throw new IncorrectOperationException("Implicitly declared class may have no name");
}
@Override
@@ -284,7 +284,7 @@ public class PsiUnnamedClassImpl extends JavaStubPsiElement<PsiClassStub<?>> imp
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof JavaElementVisitor) {
((JavaElementVisitor)visitor).visitUnnamedClass(this);
((JavaElementVisitor)visitor).visitImplicitClass(this);
}
else {
visitor.visitElement(this);
@@ -307,6 +307,6 @@ public class PsiUnnamedClassImpl extends JavaStubPsiElement<PsiClassStub<?>> imp
@Override
public String toString() {
return "PsiUnnamedClass";
return "PsiImplicitClass";
}
}
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementType.java
+1 -1
View File
@@ -37,7 +37,7 @@ public interface JavaElementType {
}
IElementType CLASS = JavaStubElementTypes.CLASS;
IElementType UNNAMED_CLASS = JavaStubElementTypes.UNNAMED_CLASS;
IElementType IMPLICIT_CLASS = JavaStubElementTypes.IMPLICIT_CLASS;
IElementType ANONYMOUS_CLASS = JavaStubElementTypes.ANONYMOUS_CLASS;
IElementType ENUM_CONSTANT_INITIALIZER = JavaStubElementTypes.ENUM_CONSTANT_INITIALIZER;
IElementType TYPE_PARAMETER_LIST = JavaStubElementTypes.TYPE_PARAMETER_LIST;
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementTypeFactory.java
+1 -1
View File
@@ -47,7 +47,7 @@ public class JavaElementTypeFactory extends AbstractBasicJavaElementTypeFactory
JavaElementType.RECORD_HEADER,
JavaElementType.PERMITS_LIST,
JavaElementType.CLASS,
JavaElementType.UNNAMED_CLASS,
JavaElementType.IMPLICIT_CLASS,
JavaElementType.ANONYMOUS_CLASS,
JavaElementType.ENUM_CONSTANT_INITIALIZER,
JavaElementType.TYPE_PARAMETER_LIST,
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ClassElement.java
+1 -1
View File
@@ -265,7 +265,7 @@ public class ClassElement extends CompositeElement implements Constants {
return findChildByType(TYPE_PARAMETER_LIST);
case ChildRole.CLASS_OR_INTERFACE_KEYWORD:
if (this instanceof UnnamedClassElement) {
if (this instanceof ImplicitClassElement) {
return null;
}
for (ASTNode child = getFirstChildNode(); child != null; child = child.getTreeNext()) {
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/UnnamedClassElement.java → java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ImplicitClassElement.java
+3 -3
View File
@@ -1,8 +1,8 @@
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.psi.impl.source.tree.java;
public class UnnamedClassElement extends ClassElement {
public UnnamedClassElement() {
super(UNNAMED_CLASS);
public class ImplicitClassElement extends ClassElement {
public ImplicitClassElement() {
super(IMPLICIT_CLASS);
}
}
java/java-psi-impl/src/com/intellij/psi/util/JavaUnnamedClassUtil.java → java/java-psi-impl/src/com/intellij/psi/util/JavaImplicitClassUtil.java
+12 -12
View File
@@ -4,41 +4,41 @@ package com.intellij.psi.util;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiImplicitClass;
import com.intellij.psi.PsiJavaFile;
import com.intellij.psi.PsiUnnamedClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public final class JavaUnnamedClassUtil {
public static boolean isFileWithUnnamedClass(@NotNull PsiFile file) {
public final class JavaImplicitClassUtil {
public static boolean isFileWithImplicitClass(@NotNull PsiFile file) {
if (file instanceof PsiJavaFile) {
PsiJavaFile javaFile = (PsiJavaFile)file;
if (getUnnamedClassFor(javaFile) != null) return true;
if (getImplicitClassFor(javaFile) != null) return true;
}
return false;
}
/**
* Retrieves the unnamed class PSI element from the given PsiFile.
* Retrieves the implicitly declared class PSI element from the given PsiFile.
*
* @param file the PsiFile from which to retrieve the unnamed class
* @return the unnamed class if found, null otherwise
* @param file the PsiFile from which to retrieve the implicitly declared class
* @return the implicitly declared class if found, null otherwise
*/
@Nullable
public static PsiUnnamedClass getUnnamedClassFor(@NotNull PsiFile file) {
public static PsiImplicitClass getImplicitClassFor(@NotNull PsiFile file) {
if (file instanceof PsiJavaFile) {
final PsiJavaFile javaFile = (PsiJavaFile)file;
PsiClass[] classes = javaFile.getClasses();
if (classes.length == 1 && classes[0] instanceof PsiUnnamedClass) {
return (PsiUnnamedClass)classes[0];
if (classes.length == 1 && classes[0] instanceof PsiImplicitClass) {
return (PsiImplicitClass)classes[0];
}
}
return null;
}
/**
* @param name the name of the unnamed class (might include the ".java" extension)
* @return the JVM name of the unnamed class
* @param name the name of the implicitly declared class (might include the ".java" extension)
* @return the JVM name of the implicitly declared class
*/
public static String getJvmName(@NotNull String name) {
return StringUtil.trimEnd(name, ".java", true);
java/java-psi-impl/src/messages/JavaErrorBundle.properties
+4 -4
View File
@@ -578,8 +578,8 @@ too.many.array.dimensions=Too many array dimensions
error.cannot.infer.pattern.type=Cannot infer pattern type: {0}
error.extra.semicolons.between.import.statements.not.allowed=Extra semicolons between import statements are not allowed
error.guard.allowed.after.patterns.only=Guard is allowed after patterns only
error.unnamed.class.contains.no.main.method=Unnamed class contains no 'main' method
error.unnamed.class.has.invalid.file.name=Unnamed class's file name is not a valid identifier
error.package.statement.not.allowed.for.unnamed.class=Package statement is not allowed for unnamed class
error.initializers.are.not.allowed.in.unnamed.classes=Initializers are not allowed in unnamed classes
error.implicit.class.contains.no.main.method=Implicitly declared class contains no 'main' method
error.implicit.class.has.invalid.file.name=Implicitly declared class's file name is not a valid identifier
error.package.statement.not.allowed.for.implicit.class=Package statement is not allowed for implicitly declared class
error.initializers.are.not.allowed.in.implicit.classes=Initializers are not allowed in implicitly declared classes
remove.unused.imports.quickfix.text=Remove unused imports
java/java-structure-view/src/com/intellij/ide/structureView/impl/java/JavaFileTreeElement.java
+5 -6
View File
@@ -20,8 +20,8 @@ import com.intellij.ide.structureView.impl.common.PsiTreeElementBase;
import com.intellij.navigation.ItemPresentation;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiClassOwner;
import com.intellij.psi.PsiUnnamedClass;
import com.intellij.psi.util.JavaUnnamedClassUtil;
import com.intellij.psi.PsiImplicitClass;
import com.intellij.psi.util.JavaImplicitClassUtil;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
@@ -45,10 +45,9 @@ public class JavaFileTreeElement extends PsiTreeElementBase<PsiClassOwner> imple
PsiClassOwner element = getElement();
if (element == null) return Collections.emptyList();
PsiClass[] classes = element.getClasses();
PsiUnnamedClass unnamedClass = JavaUnnamedClassUtil.getUnnamedClassFor(element);
if (unnamedClass != null) {
return JavaClassTreeElement.getClassChildren(unnamedClass);
PsiImplicitClass implicitClass = JavaImplicitClassUtil.getImplicitClassFor(element);
if (implicitClass != null) {
return JavaClassTreeElement.getClassChildren(implicitClass);
}
ArrayList<StructureViewTreeElement> result = new ArrayList<>();
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/HashCodeInMethod.java → java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/HashCodeInMethod.java
View File
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/HighlightInsufficientLevel.java
+13
View File
@@ -0,0 +1,13 @@
<error descr="Implicitly declared classes are not supported at language level '20'">void foo() {
}</error>
<error descr="Implicitly declared classes are not supported at language level '20'">String s = "asd";</error>
<error descr="Implicitly declared classes are not supported at language level '20'">static {
}</error>
class A {
}
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/Incorrect implicit class name with spaces.java
+1
View File
@@ -0,0 +1 @@
<error descr="Implicitly declared class's file name is not a valid identifier">void main() {}</error>
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/MainWithNonStandardSignature.java → java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/MainWithNonStandardSignature.java
View File
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/NoMainMethod.java → java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/NoMainMethod.java
View File
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/StaticInitializer.java
+7
View File
@@ -0,0 +1,7 @@
<error descr="Initializers are not allowed in implicitly declared classes" textAttributesKey="ERRORS_ATTRIBUTES">static {
}</error>
void main() {
}
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/implicitClass/WithPackageStatement.java
+5
View File
@@ -0,0 +1,5 @@
<error descr="Implicitly declared class contains no 'main' method"><error descr="Package statement is not allowed for implicitly declared class">package pack.bar;</error>
void foo() {
}</error>
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/HighlightInsufficientLevel.java
-13
View File
@@ -1,13 +0,0 @@
<error descr="Unnamed classes are not supported at language level '20'">void foo() {
}</error>
<error descr="Unnamed classes are not supported at language level '20'">String s = "asd";</error>
<error descr="Unnamed classes are not supported at language level '20'">static {
}</error>
class A {
}
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/Incorrect unnamed class name with spaces.java
-1
View File
@@ -1 +0,0 @@
<error descr="Unnamed class's file name is not a valid identifier">void main() {}</error>
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/StaticInitializer.java
-7
View File
@@ -1,7 +0,0 @@
<error descr="Initializers are not allowed in unnamed classes" textAttributesKey="ERRORS_ATTRIBUTES">static {
}</error>
void main() {
}
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unnamedClass/WithPackageStatement.java
-5
View File
@@ -1,5 +0,0 @@
<error descr="Unnamed class contains no 'main' method"><error descr="Package statement is not allowed for unnamed class">package pack.bar;</error>
void foo() {
}</error>
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unusedDecls/UnnamedClassInstanceMainWithoutParams.java → java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unusedDecls/ImplicitClassInstanceMainWithoutParams.java
View File
java/java-tests/testData/ig/com/siyeh/igtest/naming/confusing_main_method/ConfusingMainMethodInUnnamedClass.java → java/java-tests/testData/ig/com/siyeh/igtest/naming/confusing_main_method/ConfusingMainMethodInImplicitClass.java
View File
java/java-tests/testData/inspection/deadCode/unnamedClass/expected.xml → java/java-tests/testData/inspection/deadCode/implicitClass/expected.xml
View File
java/java-tests/testData/inspection/deadCode/unnamedClass/src/Main.java → java/java-tests/testData/inspection/deadCode/implicitClass/src/Main.java
View File
java/java-tests/testData/inspection/extractMethodRecommender/UnnamedClass.java → java/java-tests/testData/inspection/extractMethodRecommender/ImplicitClass.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/Errors0.txt
+1 -1
View File
@@ -1,7 +1,7 @@
PsiJavaFile:Errors0.java
PsiImportList
<empty list>
PsiUnnamedClass
PsiImplicitClass
PsiModifierList:public
PsiKeyword:public('public')
PsiWhiteSpace(' ')
java/java-tests/testData/psi/parser-full/declarationParsing/class/Errors0_node.txt
+1 -1
View File
@@ -1,7 +1,7 @@
java.FILE
IMPORT_LIST
<empty list>
UNNAMED_CLASS
IMPLICIT_CLASS
MODIFIER_LIST
PUBLIC_KEYWORD
WHITE_SPACE
java/java-tests/testData/psi/parser-full/declarationParsing/class/ExtraClosingBraceInMethod.txt
+1 -1
View File
@@ -1,7 +1,7 @@
PsiJavaFile:ExtraClosingBraceInMethod.java
PsiImportList
<empty list>
PsiUnnamedClass
PsiImplicitClass
PsiClass:Foo
PsiModifierList:
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/ExtraClosingBraceInMethod_node.txt
+1 -1
View File
@@ -1,7 +1,7 @@
java.FILE
IMPORT_LIST
<empty list>
UNNAMED_CLASS
IMPLICIT_CLASS
CLASS
MODIFIER_LIST
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass0.java → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass0.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass0.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass0.txt
+2 -2
View File
@@ -1,7 +1,7 @@
PsiJavaFile:UnnamedClass0.java
PsiJavaFile:ImplicitClass0.java
PsiImportList
<empty list>
PsiUnnamedClass
PsiImplicitClass
PsiMethod:foo
PsiModifierList:
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass0_node.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass0_node.txt
+1 -1
View File
@@ -1,7 +1,7 @@
java.FILE
IMPORT_LIST
<empty list>
UNNAMED_CLASS
IMPLICIT_CLASS
METHOD
MODIFIER_LIST
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass1.java → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass1.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass1.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass1.txt
+2 -2
View File
@@ -1,7 +1,7 @@
PsiJavaFile:UnnamedClass1.java
PsiJavaFile:ImplicitClass1.java
PsiImportList
<empty list>
PsiUnnamedClass
PsiImplicitClass
PsiField:x
PsiModifierList:
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass1_node.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass1_node.txt
+1 -1
View File
@@ -1,7 +1,7 @@
java.FILE
IMPORT_LIST
<empty list>
UNNAMED_CLASS
IMPLICIT_CLASS
FIELD
MODIFIER_LIST
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass2.java → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass2.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass2.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass2.txt
+2 -2
View File
@@ -1,7 +1,7 @@
PsiJavaFile:UnnamedClass2.java
PsiJavaFile:ImplicitClass2.java
PsiImportList
<empty list>
PsiUnnamedClass
PsiImplicitClass
PsiClassInitializer
PsiModifierList:static
PsiKeyword:static('static')
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass2_node.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass2_node.txt
+1 -1
View File
@@ -1,7 +1,7 @@
java.FILE
IMPORT_LIST
<empty list>
UNNAMED_CLASS
IMPLICIT_CLASS
CLASS_INITIALIZER
MODIFIER_LIST
STATIC_KEYWORD
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass3.java → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass3.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass3.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass3.txt
+2 -2
View File
@@ -1,4 +1,4 @@
PsiJavaFile:UnnamedClass3.java
PsiJavaFile:ImplicitClass3.java
PsiPackageStatement:pack1.pack2
PsiKeyword:package('package')
PsiWhiteSpace(' ')
@@ -28,7 +28,7 @@ PsiJavaFile:UnnamedClass3.java
<empty list>
PsiJavaToken:SEMICOLON(';')
PsiWhiteSpace('\n\n')
PsiUnnamedClass
PsiImplicitClass
PsiMethod:foo
PsiModifierList:
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass3_node.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass3_node.txt
+1 -1
View File
@@ -28,7 +28,7 @@ java.FILE
<empty list>
SEMICOLON
WHITE_SPACE
UNNAMED_CLASS
IMPLICIT_CLASS
METHOD
MODIFIER_LIST
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass4.java → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass4.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass4.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass4.txt
+2 -2
View File
@@ -1,4 +1,4 @@
PsiJavaFile:UnnamedClass4.java
PsiJavaFile:ImplicitClass4.java
PsiPackageStatement:pack1.pack2
PsiKeyword:package('package')
PsiWhiteSpace(' ')
@@ -28,7 +28,7 @@ PsiJavaFile:UnnamedClass4.java
<empty list>
PsiJavaToken:SEMICOLON(';')
PsiWhiteSpace('\n\n')
PsiUnnamedClass
PsiImplicitClass
PsiClass:A
PsiModifierList:
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass4_node.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass4_node.txt
+1 -1
View File
@@ -28,7 +28,7 @@ java.FILE
<empty list>
SEMICOLON
WHITE_SPACE
UNNAMED_CLASS
IMPLICIT_CLASS
CLASS
MODIFIER_LIST
<empty list>
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass5.java → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass5.java
View File
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass5.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass5.txt
+2 -2
View File
@@ -1,4 +1,4 @@
PsiJavaFile:UnnamedClass5.java
PsiJavaFile:ImplicitClass5.java
PsiErrorElement:'class' or 'interface' expected
PsiKeyword:package('package')
PsiWhiteSpace(' ')
@@ -6,7 +6,7 @@ PsiJavaFile:UnnamedClass5.java
<empty list>
PsiJavaToken:SEMICOLON(';')
PsiWhiteSpace('\n\n')
PsiUnnamedClass
PsiImplicitClass
PsiModifierList:native
PsiKeyword:native('native')
PsiErrorElement:Identifier or type expected
java/java-tests/testData/psi/parser-full/declarationParsing/class/UnnamedClass5_node.txt → java/java-tests/testData/psi/parser-full/declarationParsing/class/ImplicitClass5_node.txt
+1 -1
View File
@@ -6,7 +6,7 @@ java.FILE
<empty list>
SEMICOLON
WHITE_SPACE
UNNAMED_CLASS
IMPLICIT_CLASS
MODIFIER_LIST
NATIVE_KEYWORD
ERROR_ELEMENT
java/java-tests/testData/psi/parser-full/declarationParsing/class/NoClass.txt
+1 -1
View File
@@ -14,7 +14,7 @@ PsiJavaFile:NoClass.java
<empty list>
PsiJavaToken:SEMICOLON(';')
PsiWhiteSpace('\n\n')
PsiUnnamedClass
PsiImplicitClass
PsiMethod:ClassName
PsiModifierList:public
PsiKeyword:public('public')
java/java-tests/testData/psi/parser-full/declarationParsing/class/NoClass_node.txt
+1 -1
View File
@@ -14,7 +14,7 @@ java.FILE
<empty list>
SEMICOLON
WHITE_SPACE
UNNAMED_CLASS
IMPLICIT_CLASS
METHOD
MODIFIER_LIST
PUBLIC_KEYWORD
java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/UnnamedClassHighlightingTest.kt → java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/ImplicitClassHighlightingTest.kt
+3 -3
View File
@@ -6,9 +6,9 @@ import com.intellij.pom.java.LanguageLevel
import com.intellij.testFramework.IdeaTestUtil
import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase
class UnnamedClassHighlightingTest : LightJavaCodeInsightFixtureTestCase() {
class ImplicitClassHighlightingTest : LightJavaCodeInsightFixtureTestCase() {
override fun getProjectDescriptor() = JAVA_21
override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/daemonCodeAnalyzer/unnamedClass"
override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/daemonCodeAnalyzer/implicitClass"
fun testHighlightInsufficientLevel() {
IdeaTestUtil.withLevel(module, LanguageLevel.JDK_20, Runnable {
@@ -28,7 +28,7 @@ class UnnamedClassHighlightingTest : LightJavaCodeInsightFixtureTestCase() {
doTest()
}
fun `testIncorrect unnamed class name with spaces`() {
fun `testIncorrect implicit class name with spaces`() {
doTest()
}
java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/MoveMembersFixTest.kt
+1 -1
View File
@@ -8,7 +8,7 @@ import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase
class MoveMembersFixTest : LightJavaCodeInsightFixtureTestCase() {
override fun getProjectDescriptor() = JAVA_21
override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/daemonCodeAnalyzer/unnamedClass"
override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/daemonCodeAnalyzer/implicitClass"
fun testHighlightInsufficientLevel() {
IdeaTestUtil.withLevel(module, LanguageLevel.JDK_20, Runnable {
java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/UnusedSymbolLocalTest.java
+1 -1
View File
@@ -41,7 +41,7 @@ public class UnusedSymbolLocalTest extends DaemonAnalyzerTestCase {
public void testInnerUsesSelf() throws Exception { doTest(); }
public void testLocalClass() throws Exception { doTest(); }
public void testPrivateConstructor() throws Exception { doTest(); }
public void testUnnamedClassInstanceMainWithoutParams() {
public void testImplicitClassInstanceMainWithoutParams() {
IdeaTestUtil.withLevel(myModule, LanguageLevel.JDK_21_PREVIEW, () -> {
try {
doTest();
java/java-tests/testSrc/com/intellij/java/codeInsight/navigation/RunLineMarkerJava21Test.java
+2 -2
View File
@@ -10,7 +10,7 @@ import java.util.List;
public class RunLineMarkerJava21Test extends LightJavaCodeInsightFixtureTestCase {
public void testUnnamedAllowsNonStatic() {
public void testImplicitAllowsNonStatic() {
IdeaTestUtil.withLevel(getModule(), LanguageLevel.JDK_21_PREVIEW, () -> {
myFixture.configureByText("MainTest.java", """
void main<caret>() {
@@ -59,7 +59,7 @@ public class RunLineMarkerJava21Test extends LightJavaCodeInsightFixtureTestCase
});
}
public void testMainInsideInnerClassInUnnamedClassHasNoGutter() {
public void testMainInsideInnerClassInImplicitClassHasNoGutter() {
IdeaTestUtil.withLevel(getModule(), LanguageLevel.JDK_21_PREVIEW, () -> {
myFixture.configureByText("MainTest.java", """
void foo() {
java/java-tests/testSrc/com/intellij/java/codeInspection/UnusedDeclarationInspectionTest.java
+1 -1
View File
@@ -277,7 +277,7 @@ public class UnusedDeclarationInspectionTest extends AbstractUnusedDeclarationTe
public void testJunitMethodSource() {doTest();}
public void testUnnamedClass() {
public void testImplicitClass() {
IdeaTestUtil.withLevel(getModule(), LanguageLevel.JDK_21_PREVIEW, () -> {
doTest();
});
java/java-tests/testSrc/com/intellij/java/psi/JavaPsiTest.kt
+9 -9
View File
@@ -364,7 +364,7 @@ class B {}"""
assertEquals("int", parameter.typeElement!!.text)
}
fun testUnnamedFile() {
fun testImplicitFile() {
val file = configureFile(
"""
void myMethod() {
@@ -377,17 +377,17 @@ class B {}"""
int field;
""".trimIndent())
val unnamedClass = file.classes.single() as PsiUnnamedClass
TestCase.assertNull(unnamedClass.name)
val method = unnamedClass.methods.single()
val implicitClass = file.classes.single() as PsiImplicitClass
TestCase.assertNull(implicitClass.name)
val method = implicitClass.methods.single()
TestCase.assertEquals("myMethod", method.name)
val aClass = unnamedClass.innerClasses.single()
val aClass = implicitClass.innerClasses.single()
TestCase.assertEquals("A", aClass.name)
val field = unnamedClass.fields.single()
val field = implicitClass.fields.single()
TestCase.assertEquals("field", field.name)
TestCase.assertEquals(CommonClassNames.JAVA_LANG_OBJECT, unnamedClass.superClass!!.qualifiedName)
TestCase.assertEquals("Object", unnamedClass.superClassType!!.name)
InheritanceUtil.isInheritor(unnamedClass, CommonClassNames.JAVA_LANG_OBJECT)
TestCase.assertEquals(CommonClassNames.JAVA_LANG_OBJECT, implicitClass.superClass!!.qualifiedName)
TestCase.assertEquals("Object", implicitClass.superClassType!!.name)
InheritanceUtil.isInheritor(implicitClass, CommonClassNames.JAVA_LANG_OBJECT)
}
private fun configureFile(@Language("JAVA") text: String): PsiJavaFile {
java/java-tests/testSrc/com/intellij/java/psi/JavaStubsTest.groovy
+4 -3
View File
@@ -387,7 +387,7 @@ class JavaStubsTest extends LightJavaCodeInsightFixtureTestCase {
def file = myFixture.addFileToProject("a.java", "class A extends B. { int a; }")
WriteCommandAction.runWriteCommandAction(project) {
def javaFile = file as PsiJavaFile
def clazz = (javaFile.classes[0] as PsiUnnamedClass).innerClasses[0]
def clazz = (javaFile.classes[0] as PsiImplicitClass).innerClasses[0]
clazz.extendsList.referenceElements[0].delete()
}
PsiTestUtil.checkStubsMatchText(file)
@@ -418,7 +418,7 @@ class JavaStubsTest extends LightJavaCodeInsightFixtureTestCase {
def file = myFixture.addFileToProject("a.java", "class A extends.ends Foo { int a; }")
WriteCommandAction.runWriteCommandAction(project) {
def javaFile = file as PsiJavaFile
def clazz = (javaFile.classes[0] as PsiUnnamedClass).innerClasses[0]
def clazz = (javaFile.classes[0] as PsiImplicitClass).innerClasses[0]
clazz.extendsList.add(JavaPsiFacade.getElementFactory(project).createReferenceElementByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, file.resolveScope))
}
PsiTestUtil.checkStubsMatchText(file)
@@ -463,7 +463,8 @@ class JavaStubsTest extends LightJavaCodeInsightFixtureTestCase {
assert !(file as PsiFileImpl).contentsLoaded
}
void "test unnamed class"() {
void "test implicit class"() {
def psiFile = myFixture.addFileToProject("a.java", """\
void test() {
}
java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavaFormatterTest.kt
+1 -1
View File
@@ -4117,7 +4117,7 @@ public enum LevelCode {
)
}
fun testFormattingUnnamedClassMembers() {
fun testFormattingImplicitClassMembers() {
doTextTest(
"""
void before() {

Some files were not shown because too many files have changed in this diff Show More