From f7435c7f18900ea7772329bbcc4441e4d9ed79cf Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 21 May 2025 17:00:57 +0300 Subject: [PATCH 1/6] Reformatting PsiAnnotationXx. --- .../psi/PsiAnnotationAttributeValues.java | 142 +++++++++--------- .../psi/PsiAnnotationMemberValue.java | 22 +-- .../language/psi/PsiAnnotationMethod.java | 22 +-- .../java/language/psi/PsiAnnotationOwner.java | 92 ++++++------ .../psi/PsiAnnotationParameterList.java | 14 +- .../language/psi/PsiAnnotationSupport.java | 16 +- 6 files changed, 152 insertions(+), 156 deletions(-) diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java index 2ac6e5c34e..15f35891d0 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java @@ -14,93 +14,89 @@ import static consulo.util.collection.ContainerUtil.map; abstract class PsiAnnotationAttributeValue implements JvmAnnotationAttributeValue { + protected final T myElement; - protected final T myElement; - - protected PsiAnnotationAttributeValue(@Nonnull T value) { - myElement = value; - } + protected PsiAnnotationAttributeValue(@Nonnull T value) { + myElement = value; + } } class PsiAnnotationConstantValue extends PsiAnnotationAttributeValue implements JvmAnnotationConstantValue { - - PsiAnnotationConstantValue(@Nonnull PsiExpression value) { - super(value); - } - - @Nullable - @Override - public Object getConstantValue() { - PsiConstantEvaluationHelper evaluationHelper = JavaPsiFacade.getInstance(myElement.getProject()).getConstantEvaluationHelper(); - return evaluationHelper.computeConstantExpression(myElement); - } + PsiAnnotationConstantValue(@Nonnull PsiExpression value) { + super(value); + } + + @Nullable + @Override + public Object getConstantValue() { + PsiConstantEvaluationHelper evaluationHelper = JavaPsiFacade.getInstance(myElement.getProject()).getConstantEvaluationHelper(); + return evaluationHelper.computeConstantExpression(myElement); + } } class PsiAnnotationClassValue extends PsiAnnotationAttributeValue implements JvmAnnotationClassValue { - - PsiAnnotationClassValue(@Nonnull PsiClassObjectAccessExpression value) { - super(value); - } - - private PsiJavaCodeReferenceElement getReferenceElement() { - return myElement.getOperand().getInnermostComponentReferenceElement(); - } - - @Nullable - @Override - public String getQualifiedName() { - final PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); - return referenceElement == null ? null : referenceElement.getQualifiedName(); - } - - @Nullable - @Override - public JvmClass getClazz() { - PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); - if (referenceElement == null) return null; - PsiElement resolved = referenceElement.resolve(); - return resolved instanceof JvmClass ? (JvmClass)resolved : null; - } + PsiAnnotationClassValue(@Nonnull PsiClassObjectAccessExpression value) { + super(value); + } + + private PsiJavaCodeReferenceElement getReferenceElement() { + return myElement.getOperand().getInnermostComponentReferenceElement(); + } + + @Nullable + @Override + public String getQualifiedName() { + final PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); + return referenceElement == null ? null : referenceElement.getQualifiedName(); + } + + @Nullable + @Override + public JvmClass getClazz() { + PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); + if (referenceElement == null) { + return null; + } + PsiElement resolved = referenceElement.resolve(); + return resolved instanceof JvmClass ? (JvmClass)resolved : null; + } } class PsiNestedAnnotationValue extends PsiAnnotationAttributeValue implements JvmNestedAnnotationValue { - - PsiNestedAnnotationValue(@Nonnull PsiAnnotation value) { - super(value); - } - - @Nonnull - @Override - public JvmAnnotation getValue() { - return myElement; - } + PsiNestedAnnotationValue(@Nonnull PsiAnnotation value) { + super(value); + } + + @Nonnull + @Override + public JvmAnnotation getValue() { + return myElement; + } } class PsiAnnotationEnumFieldValue extends PsiAnnotationAttributeValue implements JvmAnnotationEnumFieldValue { - - private final JvmEnumField myEnumField; - - PsiAnnotationEnumFieldValue(@Nonnull PsiReferenceExpression value, @Nonnull JvmEnumField field) { - super(value); - myEnumField = field; - } - - @Nullable - @Override - public JvmEnumField getField() { - return myEnumField; - } + private final JvmEnumField myEnumField; + + PsiAnnotationEnumFieldValue(@Nonnull PsiReferenceExpression value, @Nonnull JvmEnumField field) { + super(value); + myEnumField = field; + } + + @Nullable + @Override + public JvmEnumField getField() { + return myEnumField; + } } class PsiAnnotationArrayValue extends PsiAnnotationAttributeValue implements JvmAnnotationArrayValue { - - PsiAnnotationArrayValue(@Nonnull PsiArrayInitializerMemberValue value) { - super(value); - } - - @Nonnull - @Override - public List getValues() { - return map(myElement.getInitializers(), PsiJvmConversionHelper::getAnnotationAttributeValue); - } + PsiAnnotationArrayValue(@Nonnull PsiArrayInitializerMemberValue value) { + super(value); + } + + @Nonnull + @Override + public List getValues() { + return map(myElement.getInitializers(), PsiJvmConversionHelper::getAnnotationAttributeValue); + } } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java index e6b01e8954..873de53218 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java @@ -25,16 +25,16 @@ * @author ven */ public interface PsiAnnotationMemberValue extends PsiElement { - /** - * The empty array of PSI annotation member values which can be reused to avoid unnecessary allocations. - */ - PsiAnnotationMemberValue[] EMPTY_ARRAY = new PsiAnnotationMemberValue[0]; + /** + * The empty array of PSI annotation member values which can be reused to avoid unnecessary allocations. + */ + PsiAnnotationMemberValue[] EMPTY_ARRAY = new PsiAnnotationMemberValue[0]; - ArrayFactory ARRAY_FACTORY = new ArrayFactory() { - @Nonnull - @Override - public PsiAnnotationMemberValue[] create(final int count) { - return count == 0 ? EMPTY_ARRAY : new PsiAnnotationMemberValue[count]; - } - }; + ArrayFactory ARRAY_FACTORY = new ArrayFactory() { + @Nonnull + @Override + public PsiAnnotationMemberValue[] create(final int count) { + return count == 0 ? EMPTY_ARRAY : new PsiAnnotationMemberValue[count]; + } + }; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMethod.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMethod.java index 2b50fefd3d..b9a5d61ea6 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMethod.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMethod.java @@ -24,16 +24,16 @@ * @author ven */ public interface PsiAnnotationMethod extends PsiMethod { - /** - * The empty array of PSI annotation methods which can be reused to avoid unnecessary allocations. - */ - PsiAnnotationMethod[] EMPTY_ARRAY = new PsiAnnotationMethod[0]; + /** + * The empty array of PSI annotation methods which can be reused to avoid unnecessary allocations. + */ + PsiAnnotationMethod[] EMPTY_ARRAY = new PsiAnnotationMethod[0]; - /** - * Returns the default value of the annotation element defined by the method. - * - * @return the default value of the element, or null if no default value is specified. - */ - @Nullable - PsiAnnotationMemberValue getDefaultValue(); + /** + * Returns the default value of the annotation element defined by the method. + * + * @return the default value of the element, or null if no default value is specified. + */ + @Nullable + PsiAnnotationMemberValue getDefaultValue(); } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java index 8f0605a0b1..011021b0de 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java @@ -23,55 +23,53 @@ /** * @author cdr */ -public interface PsiAnnotationOwner -{ - /** - * Returns the list of annotations syntactically contained in the element. - * - * @return the list of annotations. - */ - @Nonnull - PsiAnnotation[] getAnnotations(); +public interface PsiAnnotationOwner { + /** + * Returns the list of annotations syntactically contained in the element. + * + * @return the list of annotations. + */ + @Nonnull + PsiAnnotation[] getAnnotations(); - /** - * @return the list of annotations which are applicable to this owner - * (e.g. type annotations on method belong to its type element, not the method). - */ - @Nonnull - PsiAnnotation[] getApplicableAnnotations(); + /** + * @return the list of annotations which are applicable to this owner + * (e.g. type annotations on method belong to its type element, not the method). + */ + @Nonnull + PsiAnnotation[] getApplicableAnnotations(); - /** - * Searches the owner for an annotation with the specified fully qualified name - * and returns {@code true} if it is found. - *

- * This method is preferable over {@link #findAnnotation} - * since implementations are free not to instantiate the {@link PsiAnnotation}. - * - * @param qualifiedName the fully qualified name of the annotation to find - * @return {@code true} is such annotation is found, otherwise {@code false} - */ - default boolean hasAnnotation(@Nonnull @NonNls String qualifiedName) - { - //noinspection SSBasedInspection - return findAnnotation(qualifiedName) != null; - } + /** + * Searches the owner for an annotation with the specified fully qualified name + * and returns {@code true} if it is found. + *

+ * This method is preferable over {@link #findAnnotation} + * since implementations are free not to instantiate the {@link PsiAnnotation}. + * + * @param qualifiedName the fully qualified name of the annotation to find + * @return {@code true} is such annotation is found, otherwise {@code false} + */ + default boolean hasAnnotation(@Nonnull @NonNls String qualifiedName) { + //noinspection SSBasedInspection + return findAnnotation(qualifiedName) != null; + } - /** - * Searches the owner for an annotation with the specified fully qualified name - * and returns one if it is found. - * - * @param qualifiedName the fully qualified name of the annotation to find. - * @return the annotation instance, or null if no such annotation is found. - */ - @Nullable - PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName); + /** + * Searches the owner for an annotation with the specified fully qualified name + * and returns one if it is found. + * + * @param qualifiedName the fully qualified name of the annotation to find. + * @return the annotation instance, or null if no such annotation is found. + */ + @Nullable + PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName); - /** - * Adds a new annotation to this owner. The annotation class name will be shortened. No attributes will be defined. - * - * @param qualifiedName qualifiedName - * @return newly added annotation - */ - @Nonnull - PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName); + /** + * Adds a new annotation to this owner. The annotation class name will be shortened. No attributes will be defined. + * + * @param qualifiedName qualifiedName + * @return newly added annotation + */ + @Nonnull + PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName); } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationParameterList.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationParameterList.java index da25ca093f..cd44af8f48 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationParameterList.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationParameterList.java @@ -26,11 +26,11 @@ * @see PsiAnnotation */ public interface PsiAnnotationParameterList extends PsiElement { - /** - * Returns the array of name/value elements specified on the annotation. - * - * @return the array of name/value pairs. - */ - @Nonnull - PsiNameValuePair[] getAttributes(); + /** + * Returns the array of name/value elements specified on the annotation. + * + * @return the array of name/value pairs. + */ + @Nonnull + PsiNameValuePair[] getAttributes(); } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationSupport.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationSupport.java index 01e2415573..a0cf3a6082 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationSupport.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationSupport.java @@ -25,6 +25,7 @@ import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Map; /** @@ -32,13 +33,14 @@ */ @ExtensionAPI(ComponentScope.APPLICATION) public interface PsiAnnotationSupport extends LanguageExtension { - ExtensionPointCacheKey> CACHE_KEY = ExtensionPointCacheKey.groupBy("PsiAnnotationSupport", PsiAnnotationSupport::getLanguage); + ExtensionPointCacheKey> CACHE_KEY = + ExtensionPointCacheKey.groupBy("PsiAnnotationSupport", PsiAnnotationSupport::getLanguage); - @Nullable - static PsiAnnotationSupport forLanguage(@Nonnull Language language) { - return Application.get().getExtensionPoint(PsiAnnotationSupport.class).getOrBuildCache(CACHE_KEY).get(language); - } + @Nullable + static PsiAnnotationSupport forLanguage(@Nonnull Language language) { + return Application.get().getExtensionPoint(PsiAnnotationSupport.class).getOrBuildCache(CACHE_KEY).get(language); + } - @Nonnull - PsiLiteral createLiteralValue(@Nonnull String value, @Nonnull PsiElement context); + @Nonnull + PsiLiteral createLiteralValue(@Nonnull String value, @Nonnull PsiElement context); } From cca6d54a71647f622e98ba2d02e74f8f6877cf08 Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 21 May 2025 17:06:39 +0300 Subject: [PATCH 2/6] Refactoring PsiAnnotationXx. --- .../java/language/psi/PsiAnnotationAttributeValues.java | 6 ++++-- .../java/language/psi/PsiAnnotationMemberValue.java | 4 ++-- .../intellij/java/language/psi/PsiAnnotationOwner.java | 8 +++----- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java index 15f35891d0..68ea028dba 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java @@ -5,6 +5,7 @@ import com.intellij.java.language.jvm.JvmClass; import com.intellij.java.language.jvm.JvmEnumField; import com.intellij.java.language.jvm.annotation.*; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiElement; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; @@ -46,19 +47,20 @@ private PsiJavaCodeReferenceElement getReferenceElement() { @Nullable @Override public String getQualifiedName() { - final PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); + PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); return referenceElement == null ? null : referenceElement.getQualifiedName(); } @Nullable @Override + @RequiredReadAction public JvmClass getClazz() { PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); if (referenceElement == null) { return null; } PsiElement resolved = referenceElement.resolve(); - return resolved instanceof JvmClass ? (JvmClass)resolved : null; + return resolved instanceof JvmClass jvmClass ? jvmClass : null; } } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java index 873de53218..aa25ec8d25 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationMemberValue.java @@ -30,10 +30,10 @@ public interface PsiAnnotationMemberValue extends PsiElement { */ PsiAnnotationMemberValue[] EMPTY_ARRAY = new PsiAnnotationMemberValue[0]; - ArrayFactory ARRAY_FACTORY = new ArrayFactory() { + ArrayFactory ARRAY_FACTORY = new ArrayFactory<>() { @Nonnull @Override - public PsiAnnotationMemberValue[] create(final int count) { + public PsiAnnotationMemberValue[] create(int count) { return count == 0 ? EMPTY_ARRAY : new PsiAnnotationMemberValue[count]; } }; diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java index 011021b0de..cf538206af 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationOwner.java @@ -15,9 +15,7 @@ */ package com.intellij.java.language.psi; -import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; - import jakarta.annotation.Nullable; /** @@ -49,7 +47,7 @@ public interface PsiAnnotationOwner { * @param qualifiedName the fully qualified name of the annotation to find * @return {@code true} is such annotation is found, otherwise {@code false} */ - default boolean hasAnnotation(@Nonnull @NonNls String qualifiedName) { + default boolean hasAnnotation(@Nonnull String qualifiedName) { //noinspection SSBasedInspection return findAnnotation(qualifiedName) != null; } @@ -62,7 +60,7 @@ default boolean hasAnnotation(@Nonnull @NonNls String qualifiedName) { * @return the annotation instance, or null if no such annotation is found. */ @Nullable - PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName); + PsiAnnotation findAnnotation(@Nonnull String qualifiedName); /** * Adds a new annotation to this owner. The annotation class name will be shortened. No attributes will be defined. @@ -71,5 +69,5 @@ default boolean hasAnnotation(@Nonnull @NonNls String qualifiedName) { * @return newly added annotation */ @Nonnull - PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName); + PsiAnnotation addAnnotation(@Nonnull String qualifiedName); } From 517e5df83a7b91d9e847574319f4d44294a952d0 Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 21 May 2025 17:16:50 +0300 Subject: [PATCH 3/6] Splitting PsiAnnotationAttributeValues.java to separate class files. --- .../language/psi/PsiAnnotationArrayValue.java | 21 ++++ .../psi/PsiAnnotationAttributeValue.java | 13 +++ .../psi/PsiAnnotationAttributeValues.java | 104 ------------------ .../language/psi/PsiAnnotationClassValue.java | 38 +++++++ .../psi/PsiAnnotationConstantValue.java | 19 ++++ .../psi/PsiAnnotationEnumFieldValue.java | 22 ++++ .../psi/PsiNestedAnnotationValue.java | 18 +++ 7 files changed, 131 insertions(+), 104 deletions(-) create mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationArrayValue.java create mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValue.java delete mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java create mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationClassValue.java create mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationConstantValue.java create mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationEnumFieldValue.java create mode 100644 java-language-api/src/main/java/com/intellij/java/language/psi/PsiNestedAnnotationValue.java diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationArrayValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationArrayValue.java new file mode 100644 index 0000000000..3c222829d3 --- /dev/null +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationArrayValue.java @@ -0,0 +1,21 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.language.psi; + +import com.intellij.java.language.jvm.annotation.JvmAnnotationArrayValue; +import com.intellij.java.language.jvm.annotation.JvmAnnotationAttributeValue; +import consulo.util.collection.ContainerUtil; +import jakarta.annotation.Nonnull; + +import java.util.List; + +class PsiAnnotationArrayValue extends PsiAnnotationAttributeValue implements JvmAnnotationArrayValue { + PsiAnnotationArrayValue(@Nonnull PsiArrayInitializerMemberValue value) { + super(value); + } + + @Nonnull + @Override + public List getValues() { + return ContainerUtil.map(myElement.getInitializers(), PsiJvmConversionHelper::getAnnotationAttributeValue); + } +} diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValue.java new file mode 100644 index 0000000000..2e76ae548e --- /dev/null +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValue.java @@ -0,0 +1,13 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.language.psi; + +import com.intellij.java.language.jvm.annotation.JvmAnnotationAttributeValue; +import jakarta.annotation.Nonnull; + +abstract class PsiAnnotationAttributeValue implements JvmAnnotationAttributeValue { + protected final T myElement; + + protected PsiAnnotationAttributeValue(@Nonnull T value) { + myElement = value; + } +} diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java deleted file mode 100644 index 68ea028dba..0000000000 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationAttributeValues.java +++ /dev/null @@ -1,104 +0,0 @@ -// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -package com.intellij.java.language.psi; - -import com.intellij.java.language.jvm.JvmAnnotation; -import com.intellij.java.language.jvm.JvmClass; -import com.intellij.java.language.jvm.JvmEnumField; -import com.intellij.java.language.jvm.annotation.*; -import consulo.annotation.access.RequiredReadAction; -import consulo.language.psi.PsiElement; -import jakarta.annotation.Nonnull; -import jakarta.annotation.Nullable; - -import java.util.List; - -import static consulo.util.collection.ContainerUtil.map; - -abstract class PsiAnnotationAttributeValue implements JvmAnnotationAttributeValue { - protected final T myElement; - - protected PsiAnnotationAttributeValue(@Nonnull T value) { - myElement = value; - } -} - -class PsiAnnotationConstantValue extends PsiAnnotationAttributeValue implements JvmAnnotationConstantValue { - PsiAnnotationConstantValue(@Nonnull PsiExpression value) { - super(value); - } - - @Nullable - @Override - public Object getConstantValue() { - PsiConstantEvaluationHelper evaluationHelper = JavaPsiFacade.getInstance(myElement.getProject()).getConstantEvaluationHelper(); - return evaluationHelper.computeConstantExpression(myElement); - } -} - -class PsiAnnotationClassValue extends PsiAnnotationAttributeValue implements JvmAnnotationClassValue { - PsiAnnotationClassValue(@Nonnull PsiClassObjectAccessExpression value) { - super(value); - } - - private PsiJavaCodeReferenceElement getReferenceElement() { - return myElement.getOperand().getInnermostComponentReferenceElement(); - } - - @Nullable - @Override - public String getQualifiedName() { - PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); - return referenceElement == null ? null : referenceElement.getQualifiedName(); - } - - @Nullable - @Override - @RequiredReadAction - public JvmClass getClazz() { - PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); - if (referenceElement == null) { - return null; - } - PsiElement resolved = referenceElement.resolve(); - return resolved instanceof JvmClass jvmClass ? jvmClass : null; - } -} - -class PsiNestedAnnotationValue extends PsiAnnotationAttributeValue implements JvmNestedAnnotationValue { - PsiNestedAnnotationValue(@Nonnull PsiAnnotation value) { - super(value); - } - - @Nonnull - @Override - public JvmAnnotation getValue() { - return myElement; - } -} - -class PsiAnnotationEnumFieldValue extends PsiAnnotationAttributeValue implements JvmAnnotationEnumFieldValue { - private final JvmEnumField myEnumField; - - PsiAnnotationEnumFieldValue(@Nonnull PsiReferenceExpression value, @Nonnull JvmEnumField field) { - super(value); - myEnumField = field; - } - - @Nullable - @Override - public JvmEnumField getField() { - return myEnumField; - } -} - -class PsiAnnotationArrayValue extends PsiAnnotationAttributeValue implements JvmAnnotationArrayValue { - PsiAnnotationArrayValue(@Nonnull PsiArrayInitializerMemberValue value) { - super(value); - } - - @Nonnull - @Override - public List getValues() { - return map(myElement.getInitializers(), PsiJvmConversionHelper::getAnnotationAttributeValue); - } -} diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationClassValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationClassValue.java new file mode 100644 index 0000000000..1bd34687aa --- /dev/null +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationClassValue.java @@ -0,0 +1,38 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.language.psi; + +import com.intellij.java.language.jvm.JvmClass; +import com.intellij.java.language.jvm.annotation.JvmAnnotationClassValue; +import consulo.annotation.access.RequiredReadAction; +import consulo.language.psi.PsiElement; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; + +class PsiAnnotationClassValue extends PsiAnnotationAttributeValue implements JvmAnnotationClassValue { + PsiAnnotationClassValue(@Nonnull PsiClassObjectAccessExpression value) { + super(value); + } + + private PsiJavaCodeReferenceElement getReferenceElement() { + return myElement.getOperand().getInnermostComponentReferenceElement(); + } + + @Nullable + @Override + public String getQualifiedName() { + PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); + return referenceElement == null ? null : referenceElement.getQualifiedName(); + } + + @Nullable + @Override + @RequiredReadAction + public JvmClass getClazz() { + PsiJavaCodeReferenceElement referenceElement = getReferenceElement(); + if (referenceElement == null) { + return null; + } + PsiElement resolved = referenceElement.resolve(); + return resolved instanceof JvmClass jvmClass ? jvmClass : null; + } +} diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationConstantValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationConstantValue.java new file mode 100644 index 0000000000..2fab7a1f58 --- /dev/null +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationConstantValue.java @@ -0,0 +1,19 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.language.psi; + +import com.intellij.java.language.jvm.annotation.JvmAnnotationConstantValue; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; + +class PsiAnnotationConstantValue extends PsiAnnotationAttributeValue implements JvmAnnotationConstantValue { + PsiAnnotationConstantValue(@Nonnull PsiExpression value) { + super(value); + } + + @Nullable + @Override + public Object getConstantValue() { + PsiConstantEvaluationHelper evaluationHelper = JavaPsiFacade.getInstance(myElement.getProject()).getConstantEvaluationHelper(); + return evaluationHelper.computeConstantExpression(myElement); + } +} diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationEnumFieldValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationEnumFieldValue.java new file mode 100644 index 0000000000..38f676572b --- /dev/null +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiAnnotationEnumFieldValue.java @@ -0,0 +1,22 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.language.psi; + +import com.intellij.java.language.jvm.JvmEnumField; +import com.intellij.java.language.jvm.annotation.JvmAnnotationEnumFieldValue; +import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; + +class PsiAnnotationEnumFieldValue extends PsiAnnotationAttributeValue implements JvmAnnotationEnumFieldValue { + private final JvmEnumField myEnumField; + + PsiAnnotationEnumFieldValue(@Nonnull PsiReferenceExpression value, @Nonnull JvmEnumField field) { + super(value); + myEnumField = field; + } + + @Nullable + @Override + public JvmEnumField getField() { + return myEnumField; + } +} diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiNestedAnnotationValue.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiNestedAnnotationValue.java new file mode 100644 index 0000000000..3ac3a19b69 --- /dev/null +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiNestedAnnotationValue.java @@ -0,0 +1,18 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.language.psi; + +import com.intellij.java.language.jvm.JvmAnnotation; +import com.intellij.java.language.jvm.annotation.JvmNestedAnnotationValue; +import jakarta.annotation.Nonnull; + +class PsiNestedAnnotationValue extends PsiAnnotationAttributeValue implements JvmNestedAnnotationValue { + PsiNestedAnnotationValue(@Nonnull PsiAnnotation value) { + super(value); + } + + @Nonnull + @Override + public JvmAnnotation getValue() { + return myElement; + } +} From 628b23b9c6c21e4997eca974eb40ac3aa8138e44 Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 21 May 2025 17:25:35 +0300 Subject: [PATCH 4/6] Reformatting descendants of PsiAnnotationOwner. --- .../intellij/java/language/psi/PsiType.java | 669 +++++++-------- .../impl/compiled/ClsModifierListImpl.java | 274 ++++--- .../psi/impl/compiled/ClsTypeElementImpl.java | 498 +++++------ .../impl/compiled/ClsTypeParameterImpl.java | 701 ++++++++-------- .../psi/impl/light/LightModifierList.java | 190 ++--- .../impl/psi/impl/light/LightTypeElement.java | 114 +-- .../psi/impl/light/LightTypeParameter.java | 110 +-- .../impl/light/LightTypeParameterBuilder.java | 88 +- .../psi/impl/source/JavaStubPsiElement.java | 395 ++++----- .../psi/impl/source/PsiModifierListImpl.java | 599 +++++++------- .../psi/impl/source/PsiTypeElementImpl.java | 771 +++++++++--------- .../tree/java/PsiTypeParameterImpl.java | 723 ++++++++-------- 12 files changed, 2612 insertions(+), 2520 deletions(-) diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java index 9464b6fc74..aebf6bbb72 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java @@ -28,359 +28,360 @@ * Representation of Java type (primitive type, array or class type). */ public abstract class PsiType implements PsiAnnotationOwner, Cloneable, JvmType { - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType BYTE = new PsiPrimitiveType("byte", CommonClassNames.JAVA_LANG_BYTE); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType CHAR = new PsiPrimitiveType("char", CommonClassNames.JAVA_LANG_CHARACTER); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType DOUBLE = new PsiPrimitiveType("double", CommonClassNames.JAVA_LANG_DOUBLE); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType FLOAT = new PsiPrimitiveType("float", CommonClassNames.JAVA_LANG_FLOAT); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType INT = new PsiPrimitiveType("int", CommonClassNames.JAVA_LANG_INTEGER); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType LONG = new PsiPrimitiveType("long", CommonClassNames.JAVA_LANG_LONG); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType SHORT = new PsiPrimitiveType("short", CommonClassNames.JAVA_LANG_SHORT); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType BOOLEAN = new PsiPrimitiveType("boolean", CommonClassNames.JAVA_LANG_BOOLEAN); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType VOID = new PsiPrimitiveType("void", CommonClassNames.JAVA_LANG_VOID); - @SuppressWarnings("StaticInitializerReferencesSubClass") - public static final PsiPrimitiveType NULL = new PsiPrimitiveType("null", (String) null); - - public static final PsiType[] EMPTY_ARRAY = new PsiType[0]; - public static final ArrayFactory ARRAY_FACTORY = count -> count == 0 ? EMPTY_ARRAY : new PsiType[count]; - - @Nonnull - public static PsiType[] createArray(int count) { - return ARRAY_FACTORY.create(count); - } - - private TypeAnnotationProvider myAnnotationProvider; - - /** - * Constructs a PsiType with given annotations - */ - protected PsiType(@Nonnull final PsiAnnotation[] annotations) { - this(TypeAnnotationProvider.Static.create(annotations)); - } - - /** - * Constructs a PsiType that will take its annotations from the given annotation provider. - */ - protected PsiType(@Nonnull TypeAnnotationProvider annotations) { - myAnnotationProvider = annotations; - } - - @Nonnull - public PsiType annotate(@Nonnull TypeAnnotationProvider provider) { - if (provider == myAnnotationProvider) { - return this; + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType BYTE = new PsiPrimitiveType("byte", CommonClassNames.JAVA_LANG_BYTE); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType CHAR = new PsiPrimitiveType("char", CommonClassNames.JAVA_LANG_CHARACTER); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType DOUBLE = new PsiPrimitiveType("double", CommonClassNames.JAVA_LANG_DOUBLE); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType FLOAT = new PsiPrimitiveType("float", CommonClassNames.JAVA_LANG_FLOAT); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType INT = new PsiPrimitiveType("int", CommonClassNames.JAVA_LANG_INTEGER); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType LONG = new PsiPrimitiveType("long", CommonClassNames.JAVA_LANG_LONG); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType SHORT = new PsiPrimitiveType("short", CommonClassNames.JAVA_LANG_SHORT); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType BOOLEAN = new PsiPrimitiveType("boolean", CommonClassNames.JAVA_LANG_BOOLEAN); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType VOID = new PsiPrimitiveType("void", CommonClassNames.JAVA_LANG_VOID); + @SuppressWarnings("StaticInitializerReferencesSubClass") + public static final PsiPrimitiveType NULL = new PsiPrimitiveType("null", (String)null); + + public static final PsiType[] EMPTY_ARRAY = new PsiType[0]; + public static final ArrayFactory ARRAY_FACTORY = count -> count == 0 ? EMPTY_ARRAY : new PsiType[count]; + + @Nonnull + public static PsiType[] createArray(int count) { + return ARRAY_FACTORY.create(count); } - try { - PsiType copy = (PsiType) clone(); - copy.myAnnotationProvider = provider; - return copy; - } catch (CloneNotSupportedException e) { - throw new RuntimeException(e); + private TypeAnnotationProvider myAnnotationProvider; + + /** + * Constructs a PsiType with given annotations + */ + protected PsiType(@Nonnull final PsiAnnotation[] annotations) { + this(TypeAnnotationProvider.Static.create(annotations)); } - } - - /** - * Creates array type with this type as a component. - */ - @Nonnull - public PsiArrayType createArrayType() { - return new PsiArrayType(this); - } - - /** - * @deprecated use {@link #annotate(TypeAnnotationProvider)} (to be removed in IDEA 18) - */ - public PsiArrayType createArrayType(@Nonnull PsiAnnotation... annotations) { - return new PsiArrayType(this, annotations); - } - - /** - * Returns text of the type that can be presented to a user (references normally non-qualified). - */ - @Nonnull - public String getPresentableText(boolean annotated) { - return getPresentableText(); - } - - /** - * Same as {@code getPresentableText(false)}. - */ - @Nonnull - public abstract String getPresentableText(); - - /** - * Returns canonical representation of the type (all references fully-qualified). - */ - @Nonnull - public String getCanonicalText(boolean annotated) { - return getCanonicalText(); - } - - /** - * Same as {@code getCanonicalText(false)}. - */ - @Nonnull - public abstract String getCanonicalText(); - - /** - * Return canonical text of the type with some internal details added for presentational purposes. Use with care. - * todo[r.sh] merge with getPresentableText() - */ - @Nonnull - public String getInternalCanonicalText() { - return getCanonicalText(); - } - - /** - * Checks if the type is currently valid. - * - * @return true if the type is valid, false otherwise. - * @see PsiElement#isValid() - */ - public abstract boolean isValid(); - - /** - * @return true if values of type {@code type} can be assigned to rvalues of this type. - */ - public boolean isAssignableFrom(@Nonnull PsiType type) { - return TypeConversionUtil.isAssignable(this, type); - } - - /** - * Checks whether values of type {@code type} can be casted to this type. - */ - public boolean isConvertibleFrom(@Nonnull PsiType type) { - return TypeConversionUtil.areTypesConvertible(type, this); - } - - /** - * Checks if the specified string is equivalent to the canonical text of the type. - * - * @param text the text to compare with. - * @return true if the string is equivalent to the type, false otherwise - */ - public abstract boolean equalsToText(@Nonnull String text); - - /** - * Returns the class type for qualified class name. - * - * @param qName qualified class name. - * @param project - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - public static PsiClassType getTypeByName(String qName, Project project, GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); - return factory.createTypeByFQClassName(qName, resolveScope); - } - - /** - * Returns the class type for the java.lang.Object class. - * - * @param manager the PSI manager used to create the class type. - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - @Nonnull - public static PsiClassType getJavaLangObject(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(CommonClassNames.JAVA_LANG_OBJECT, manager.getProject(), resolveScope); - } - - /** - * Returns the class type for the java.lang.Class class. - * - * @param manager the PSI manager used to create the class type. - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - @Nonnull - public static PsiClassType getJavaLangClass(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(CommonClassNames.JAVA_LANG_CLASS, manager.getProject(), resolveScope); - } - - /** - * Returns the class type for the java.lang.Throwable class. - * - * @param manager the PSI manager used to create the class type. - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - @Nonnull - public static PsiClassType getJavaLangThrowable(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(CommonClassNames.JAVA_LANG_THROWABLE, manager.getProject(), resolveScope); - } - - /** - * Returns the class type for the java.lang.String class. - * - * @param manager the PSI manager used to create the class type. - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - @Nonnull - public static PsiClassType getJavaLangString(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(CommonClassNames.JAVA_LANG_STRING, manager.getProject(), resolveScope); - } - - /** - * Returns the class type for the java.lang.Error class. - * - * @param manager the PSI manager used to create the class type. - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - @Nonnull - public static PsiClassType getJavaLangError(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(CommonClassNames.JAVA_LANG_ERROR, manager.getProject(), resolveScope); - } - - /** - * Returns the class type for the java.lang.RuntimeException class. - * - * @param manager the PSI manager used to create the class type. - * @param resolveScope the scope in which the class is searched. - * @return the class instance. - */ - @Nonnull - public static PsiClassType getJavaLangRuntimeException(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { - return getTypeByName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, manager.getProject(), resolveScope); - } - - /** - * Passes the type to the specified visitor. - * - * @param visitor the visitor to accept the type. - * @return the value returned by the visitor. - */ - public abstract A accept(@Nonnull PsiTypeVisitor visitor); - - /** - * Returns the number of array dimensions for the type. - * - * @return the number of dimensions, or 0 if the type is not an array type. - */ - public final int getArrayDimensions() { - PsiType type = this; - int dims = 0; - while (type instanceof PsiArrayType) { - dims++; - type = ((PsiArrayType) type).getComponentType(); + + /** + * Constructs a PsiType that will take its annotations from the given annotation provider. + */ + protected PsiType(@Nonnull TypeAnnotationProvider annotations) { + myAnnotationProvider = annotations; } - return dims; - } - - /** - * Returns the innermost component type for an array type. - * - * @return the innermost (non-array) component of the type, or {@code this} if the type is not - * an array type. - */ - @Nonnull - public final PsiType getDeepComponentType() { - PsiType type = this; - while (type instanceof PsiArrayType) { - type = ((PsiArrayType) type).getComponentType(); + + @Nonnull + public PsiType annotate(@Nonnull TypeAnnotationProvider provider) { + if (provider == myAnnotationProvider) { + return this; + } + + try { + PsiType copy = (PsiType)clone(); + copy.myAnnotationProvider = provider; + return copy; + } + catch (CloneNotSupportedException e) { + throw new RuntimeException(e); + } } - return type; - } - - /** - * Returns the scope in which the reference to the underlying class of a class type is searched. - * - * @return the resolve scope instance, or null if the type is a primitive or an array of primitives. - */ - @Nullable - public abstract GlobalSearchScope getResolveScope(); - - /** - * Returns the list of superclass types for a class type. - * - * @return the array of superclass types, or an empty array if the type is not a class type. - */ - @Nonnull - public abstract PsiType[] getSuperTypes(); - - /** - * @return provider for this type's annotations. Can be used to construct other PsiType instances - * without actually evaluating the annotation array, which can be computationally expensive sometimes. - */ - @Nonnull - public final TypeAnnotationProvider getAnnotationProvider() { - return myAnnotationProvider; - } - - /** - * @return annotations for this type. Uses {@link #getAnnotationProvider()} to retrieve the annotations. - */ - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - return myAnnotationProvider.getAnnotations(); - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - for (PsiAnnotation annotation : getAnnotations()) { - if (qualifiedName.equals(annotation.getQualifiedName())) { - return annotation; - } + + /** + * Creates array type with this type as a component. + */ + @Nonnull + public PsiArrayType createArrayType() { + return new PsiArrayType(this); } - return null; - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { - throw new UnsupportedOperationException(); - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getAnnotations(); - } - - @Override - public String toString() { - return "PsiType:" + getPresentableText(); - } - - protected static abstract class Stub extends PsiType { - protected Stub(@Nonnull PsiAnnotation[] annotations) { - super(annotations); + + /** + * @deprecated use {@link #annotate(TypeAnnotationProvider)} (to be removed in IDEA 18) + */ + public PsiArrayType createArrayType(@Nonnull PsiAnnotation... annotations) { + return new PsiArrayType(this, annotations); } - protected Stub(@Nonnull TypeAnnotationProvider annotations) { - super(annotations); + /** + * Returns text of the type that can be presented to a user (references normally non-qualified). + */ + @Nonnull + public String getPresentableText(boolean annotated) { + return getPresentableText(); } + /** + * Same as {@code getPresentableText(false)}. + */ @Nonnull - @Override - public final String getPresentableText() { - return getPresentableText(false); + public abstract String getPresentableText(); + + /** + * Returns canonical representation of the type (all references fully-qualified). + */ + @Nonnull + public String getCanonicalText(boolean annotated) { + return getCanonicalText(); } + /** + * Same as {@code getCanonicalText(false)}. + */ @Nonnull - @Override - public abstract String getPresentableText(boolean annotated); + public abstract String getCanonicalText(); + + /** + * Return canonical text of the type with some internal details added for presentational purposes. Use with care. + * todo[r.sh] merge with getPresentableText() + */ + @Nonnull + public String getInternalCanonicalText() { + return getCanonicalText(); + } + + /** + * Checks if the type is currently valid. + * + * @return true if the type is valid, false otherwise. + * @see PsiElement#isValid() + */ + public abstract boolean isValid(); + + /** + * @return true if values of type {@code type} can be assigned to rvalues of this type. + */ + public boolean isAssignableFrom(@Nonnull PsiType type) { + return TypeConversionUtil.isAssignable(this, type); + } + + /** + * Checks whether values of type {@code type} can be casted to this type. + */ + public boolean isConvertibleFrom(@Nonnull PsiType type) { + return TypeConversionUtil.areTypesConvertible(type, this); + } + + /** + * Checks if the specified string is equivalent to the canonical text of the type. + * + * @param text the text to compare with. + * @return true if the string is equivalent to the type, false otherwise + */ + public abstract boolean equalsToText(@Nonnull String text); + + /** + * Returns the class type for qualified class name. + * + * @param qName qualified class name. + * @param project + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + public static PsiClassType getTypeByName(String qName, Project project, GlobalSearchScope resolveScope) { + PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + return factory.createTypeByFQClassName(qName, resolveScope); + } + + /** + * Returns the class type for the java.lang.Object class. + * + * @param manager the PSI manager used to create the class type. + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + @Nonnull + public static PsiClassType getJavaLangObject(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { + return getTypeByName(CommonClassNames.JAVA_LANG_OBJECT, manager.getProject(), resolveScope); + } + + /** + * Returns the class type for the java.lang.Class class. + * + * @param manager the PSI manager used to create the class type. + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + @Nonnull + public static PsiClassType getJavaLangClass(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { + return getTypeByName(CommonClassNames.JAVA_LANG_CLASS, manager.getProject(), resolveScope); + } + + /** + * Returns the class type for the java.lang.Throwable class. + * + * @param manager the PSI manager used to create the class type. + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + @Nonnull + public static PsiClassType getJavaLangThrowable(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { + return getTypeByName(CommonClassNames.JAVA_LANG_THROWABLE, manager.getProject(), resolveScope); + } + /** + * Returns the class type for the java.lang.String class. + * + * @param manager the PSI manager used to create the class type. + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ @Nonnull + public static PsiClassType getJavaLangString(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { + return getTypeByName(CommonClassNames.JAVA_LANG_STRING, manager.getProject(), resolveScope); + } + + /** + * Returns the class type for the java.lang.Error class. + * + * @param manager the PSI manager used to create the class type. + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + @Nonnull + public static PsiClassType getJavaLangError(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { + return getTypeByName(CommonClassNames.JAVA_LANG_ERROR, manager.getProject(), resolveScope); + } + + /** + * Returns the class type for the java.lang.RuntimeException class. + * + * @param manager the PSI manager used to create the class type. + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + @Nonnull + public static PsiClassType getJavaLangRuntimeException(@Nonnull PsiManager manager, @Nonnull GlobalSearchScope resolveScope) { + return getTypeByName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, manager.getProject(), resolveScope); + } + + /** + * Passes the type to the specified visitor. + * + * @param visitor the visitor to accept the type. + * @return the value returned by the visitor. + */ + public abstract A accept(@Nonnull PsiTypeVisitor visitor); + + /** + * Returns the number of array dimensions for the type. + * + * @return the number of dimensions, or 0 if the type is not an array type. + */ + public final int getArrayDimensions() { + PsiType type = this; + int dims = 0; + while (type instanceof PsiArrayType) { + dims++; + type = ((PsiArrayType)type).getComponentType(); + } + return dims; + } + + /** + * Returns the innermost component type for an array type. + * + * @return the innermost (non-array) component of the type, or {@code this} if the type is not + * an array type. + */ + @Nonnull + public final PsiType getDeepComponentType() { + PsiType type = this; + while (type instanceof PsiArrayType) { + type = ((PsiArrayType)type).getComponentType(); + } + return type; + } + + /** + * Returns the scope in which the reference to the underlying class of a class type is searched. + * + * @return the resolve scope instance, or null if the type is a primitive or an array of primitives. + */ + @Nullable + public abstract GlobalSearchScope getResolveScope(); + + /** + * Returns the list of superclass types for a class type. + * + * @return the array of superclass types, or an empty array if the type is not a class type. + */ + @Nonnull + public abstract PsiType[] getSuperTypes(); + + /** + * @return provider for this type's annotations. Can be used to construct other PsiType instances + * without actually evaluating the annotation array, which can be computationally expensive sometimes. + */ + @Nonnull + public final TypeAnnotationProvider getAnnotationProvider() { + return myAnnotationProvider; + } + + /** + * @return annotations for this type. Uses {@link #getAnnotationProvider()} to retrieve the annotations. + */ + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + return myAnnotationProvider.getAnnotations(); + } + + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + for (PsiAnnotation annotation : getAnnotations()) { + if (qualifiedName.equals(annotation.getQualifiedName())) { + return annotation; + } + } + return null; + } + @Override - public final String getCanonicalText() { - return getCanonicalText(false); + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { + throw new UnsupportedOperationException(); } + @Override @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getAnnotations(); + } + @Override - public abstract String getCanonicalText(boolean annotated); - } + public String toString() { + return "PsiType:" + getPresentableText(); + } + + protected static abstract class Stub extends PsiType { + protected Stub(@Nonnull PsiAnnotation[] annotations) { + super(annotations); + } + + protected Stub(@Nonnull TypeAnnotationProvider annotations) { + super(annotations); + } + + @Nonnull + @Override + public final String getPresentableText() { + return getPresentableText(false); + } + + @Nonnull + @Override + public abstract String getPresentableText(boolean annotated); + + @Nonnull + @Override + public final String getCanonicalText() { + return getCanonicalText(false); + } + + @Nonnull + @Override + public abstract String getCanonicalText(boolean annotated); + } } \ No newline at end of file diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java index 4200445669..e2ada5b4ea 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java @@ -30,140 +30,144 @@ import jakarta.annotation.Nonnull; public class ClsModifierListImpl extends ClsRepositoryPsiElement implements PsiModifierList { - public ClsModifierListImpl(PsiModifierListStub stub) { - super(stub); - } - - @Override - @Nonnull - public PsiElement[] getChildren() { - return getAnnotations(); - } - - @Override - public boolean hasModifierProperty(@Nonnull String name) { - return ModifierFlags.hasModifierProperty(name, getStub().getModifiersMask()); - } - - @Override - public boolean hasExplicitModifier(@Nonnull String name) { - return hasModifierProperty(name); - } - - @Override - public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { - throw cannotModifyException(this); - } - - @Override - public void checkSetModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { - throw cannotModifyException(this); - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - return getStub().getChildrenByType(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY); - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getAnnotations(); - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - return PsiImplUtil.findAnnotation(this, qualifiedName); - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { - throw cannotModifyException(this); - } - - @Override - public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { - PsiElement parent = getParent(); - PsiAnnotation[] annotations = getAnnotations(); - boolean separateAnnotations = parent instanceof PsiClass || parent instanceof PsiMethod || parent instanceof PsiField || parent instanceof PsiJavaModule; - - for (PsiAnnotation annotation : annotations) { - appendText(annotation, indentLevel, buffer, separateAnnotations ? NEXT_LINE : " "); + public ClsModifierListImpl(PsiModifierListStub stub) { + super(stub); + } + + @Override + @Nonnull + public PsiElement[] getChildren() { + return getAnnotations(); + } + + @Override + public boolean hasModifierProperty(@Nonnull String name) { + return ModifierFlags.hasModifierProperty(name, getStub().getModifiersMask()); + } + + @Override + public boolean hasExplicitModifier(@Nonnull String name) { + return hasModifierProperty(name); + } + + @Override + public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { + throw cannotModifyException(this); + } + + @Override + public void checkSetModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { + throw cannotModifyException(this); + } + + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + return getStub().getChildrenByType(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY); + } + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getAnnotations(); + } + + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + return PsiImplUtil.findAnnotation(this, qualifiedName); + } + + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { + throw cannotModifyException(this); + } + + @Override + public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { + PsiElement parent = getParent(); + PsiAnnotation[] annotations = getAnnotations(); + boolean separateAnnotations = parent instanceof PsiClass + || parent instanceof PsiMethod + || parent instanceof PsiField + || parent instanceof PsiJavaModule; + + for (PsiAnnotation annotation : annotations) { + appendText(annotation, indentLevel, buffer, separateAnnotations ? NEXT_LINE : " "); + } + + boolean isClass = parent instanceof PsiClass; + boolean isInterface = isClass && ((PsiClass)parent).isInterface(); + boolean isEnum = isClass && ((PsiClass)parent).isEnum(); + boolean isInterfaceClass = isClass && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface(); + boolean isMethod = parent instanceof PsiMethod; + boolean isInterfaceMethod = isMethod && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface(); + boolean isField = parent instanceof PsiField; + boolean isInterfaceField = isField && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface(); + boolean isEnumConstant = parent instanceof PsiEnumConstant; + + if (hasModifierProperty(PsiModifier.PUBLIC) && !isInterfaceMethod && !isInterfaceField && !isInterfaceClass && !isEnumConstant) { + buffer.append(PsiModifier.PUBLIC).append(' '); + } + if (hasModifierProperty(PsiModifier.PROTECTED)) { + buffer.append(PsiModifier.PROTECTED).append(' '); + } + if (hasModifierProperty(PsiModifier.PRIVATE)) { + buffer.append(PsiModifier.PRIVATE).append(' '); + } + if (hasModifierProperty(PsiModifier.STATIC) && !isInterfaceField && !isEnumConstant) { + buffer.append(PsiModifier.STATIC).append(' '); + } + if (hasModifierProperty(PsiModifier.ABSTRACT) && !isInterface && !isInterfaceMethod) { + buffer.append(PsiModifier.ABSTRACT).append(' '); + } + if (hasModifierProperty(PsiModifier.FINAL) && !isEnum && !isInterfaceField && !isEnumConstant) { + buffer.append(PsiModifier.FINAL).append(' '); + } + if (hasModifierProperty(PsiModifier.NATIVE)) { + buffer.append(PsiModifier.NATIVE).append(' '); + } + if (hasModifierProperty(PsiModifier.SYNCHRONIZED)) { + buffer.append(PsiModifier.SYNCHRONIZED).append(' '); + } + if (hasModifierProperty(PsiModifier.TRANSIENT)) { + buffer.append(PsiModifier.TRANSIENT).append(' '); + } + if (hasModifierProperty(PsiModifier.VOLATILE)) { + buffer.append(PsiModifier.VOLATILE).append(' '); + } + if (hasModifierProperty(PsiModifier.STRICTFP)) { + buffer.append(PsiModifier.STRICTFP).append(' '); + } + if (hasModifierProperty(PsiModifier.DEFAULT)) { + buffer.append(PsiModifier.DEFAULT).append(' '); + } + if (hasModifierProperty(PsiModifier.OPEN)) { + buffer.append(PsiModifier.OPEN).append(' '); + } + if (hasModifierProperty(PsiModifier.TRANSITIVE)) { + buffer.append(PsiModifier.TRANSITIVE).append(' '); + } + } + + @Override + public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorException { + setMirrorCheckingType(element, JavaElementType.MODIFIER_LIST); + setMirrors(getAnnotations(), SourceTreeToPsiMap.treeToPsiNotNull(element).getAnnotations()); + } + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitModifierList(this); + } + else { + visitor.visitElement(this); + } + } + + @Override + public String toString() { + return "PsiModifierList"; } - - boolean isClass = parent instanceof PsiClass; - boolean isInterface = isClass && ((PsiClass) parent).isInterface(); - boolean isEnum = isClass && ((PsiClass) parent).isEnum(); - boolean isInterfaceClass = isClass && parent.getParent() instanceof PsiClass && ((PsiClass) parent.getParent()).isInterface(); - boolean isMethod = parent instanceof PsiMethod; - boolean isInterfaceMethod = isMethod && parent.getParent() instanceof PsiClass && ((PsiClass) parent.getParent()).isInterface(); - boolean isField = parent instanceof PsiField; - boolean isInterfaceField = isField && parent.getParent() instanceof PsiClass && ((PsiClass) parent.getParent()).isInterface(); - boolean isEnumConstant = parent instanceof PsiEnumConstant; - - if (hasModifierProperty(PsiModifier.PUBLIC) && !isInterfaceMethod && !isInterfaceField && !isInterfaceClass && !isEnumConstant) { - buffer.append(PsiModifier.PUBLIC).append(' '); - } - if (hasModifierProperty(PsiModifier.PROTECTED)) { - buffer.append(PsiModifier.PROTECTED).append(' '); - } - if (hasModifierProperty(PsiModifier.PRIVATE)) { - buffer.append(PsiModifier.PRIVATE).append(' '); - } - if (hasModifierProperty(PsiModifier.STATIC) && !isInterfaceField && !isEnumConstant) { - buffer.append(PsiModifier.STATIC).append(' '); - } - if (hasModifierProperty(PsiModifier.ABSTRACT) && !isInterface && !isInterfaceMethod) { - buffer.append(PsiModifier.ABSTRACT).append(' '); - } - if (hasModifierProperty(PsiModifier.FINAL) && !isEnum && !isInterfaceField && !isEnumConstant) { - buffer.append(PsiModifier.FINAL).append(' '); - } - if (hasModifierProperty(PsiModifier.NATIVE)) { - buffer.append(PsiModifier.NATIVE).append(' '); - } - if (hasModifierProperty(PsiModifier.SYNCHRONIZED)) { - buffer.append(PsiModifier.SYNCHRONIZED).append(' '); - } - if (hasModifierProperty(PsiModifier.TRANSIENT)) { - buffer.append(PsiModifier.TRANSIENT).append(' '); - } - if (hasModifierProperty(PsiModifier.VOLATILE)) { - buffer.append(PsiModifier.VOLATILE).append(' '); - } - if (hasModifierProperty(PsiModifier.STRICTFP)) { - buffer.append(PsiModifier.STRICTFP).append(' '); - } - if (hasModifierProperty(PsiModifier.DEFAULT)) { - buffer.append(PsiModifier.DEFAULT).append(' '); - } - if (hasModifierProperty(PsiModifier.OPEN)) { - buffer.append(PsiModifier.OPEN).append(' '); - } - if (hasModifierProperty(PsiModifier.TRANSITIVE)) { - buffer.append(PsiModifier.TRANSITIVE).append(' '); - } - } - - @Override - public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorException { - setMirrorCheckingType(element, JavaElementType.MODIFIER_LIST); - setMirrors(getAnnotations(), SourceTreeToPsiMap.treeToPsiNotNull(element).getAnnotations()); - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor) visitor).visitModifierList(this); - } else { - visitor.visitElement(this); - } - } - - @Override - public String toString() { - return "PsiModifierList"; - } } \ No newline at end of file diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java index 4026980354..d3852d5ba6 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java @@ -19,274 +19,280 @@ import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.List; import java.util.Objects; public class ClsTypeElementImpl extends ClsElementImpl implements PsiTypeElement { - static final char VARIANCE_NONE = '\0'; - static final char VARIANCE_EXTENDS = '+'; - static final char VARIANCE_SUPER = '-'; - static final char VARIANCE_INVARIANT = '*'; - - private final PsiElement myParent; - private final - @Nonnull - String myTypeText; - private final char myVariance; - private final - @Nonnull - TypeAnnotationContainer myAnnotations; - private final - @Nonnull - NullableLazyValue myChild; - private final - @Nonnull - NotNullLazyValue myCachedType; - - public ClsTypeElementImpl(@Nonnull PsiElement parent, - @Nonnull String typeText, - char variance) { - this(parent, typeText, variance, TypeAnnotationContainer.EMPTY); - } - - ClsTypeElementImpl(@Nullable PsiElement parent, @Nonnull TypeInfo typeInfo) { - this(parent, Objects.requireNonNull(TypeInfo.createTypeText(typeInfo)), VARIANCE_NONE, typeInfo.getTypeAnnotations()); - } - - ClsTypeElementImpl(@Nullable PsiElement parent, - @Nonnull String typeText, - char variance, - @Nonnull TypeAnnotationContainer annotations) { - myParent = parent; - myTypeText = TypeInfo.internFrequentType(typeText); - myVariance = variance; - myAnnotations = annotations; - myChild = new AtomicNullableLazyValue() { - @Override - protected ClsElementImpl compute() { - return calculateChild(); - } - }; - myCachedType = AtomicNotNullLazyValue.createValue(this::calculateType); - } - - @Override - @Nonnull - public PsiElement[] getChildren() { - ClsElementImpl child = myChild.getValue(); - return child != null ? new PsiElement[]{child} : PsiElement.EMPTY_ARRAY; - } - - @Override - public PsiElement getParent() { - return myParent; - } - - @Override - public String getText() { - final String shortClassName = PsiNameHelper.getShortClassName(myTypeText); - return decorateTypeText(shortClassName); - } - - private String decorateTypeText(final String shortClassName) { - switch (myVariance) { - case VARIANCE_NONE: - return shortClassName; - case VARIANCE_EXTENDS: - return PsiWildcardType.EXTENDS_PREFIX + shortClassName; - case VARIANCE_SUPER: - return PsiWildcardType.SUPER_PREFIX + shortClassName; - case VARIANCE_INVARIANT: - return "?"; - default: - assert false : myVariance; - return null; + static final char VARIANCE_NONE = '\0'; + static final char VARIANCE_EXTENDS = '+'; + static final char VARIANCE_SUPER = '-'; + static final char VARIANCE_INVARIANT = '*'; + + private final PsiElement myParent; + @Nonnull + private final String myTypeText; + private final char myVariance; + @Nonnull + private final TypeAnnotationContainer myAnnotations; + @Nonnull + private final NullableLazyValue myChild; + @Nonnull + private final NotNullLazyValue myCachedType; + + public ClsTypeElementImpl(@Nonnull PsiElement parent, @Nonnull String typeText, char variance) { + this(parent, typeText, variance, TypeAnnotationContainer.EMPTY); } - } - public String getCanonicalText() { - return decorateTypeText(myTypeText); - } + ClsTypeElementImpl(@Nullable PsiElement parent, @Nonnull TypeInfo typeInfo) { + this(parent, Objects.requireNonNull(TypeInfo.createTypeText(typeInfo)), VARIANCE_NONE, typeInfo.getTypeAnnotations()); + } - @Override - public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { - buffer.append(getType().getCanonicalText(true)); - } + ClsTypeElementImpl( + @Nullable PsiElement parent, + @Nonnull String typeText, + char variance, + @Nonnull TypeAnnotationContainer annotations + ) { + myParent = parent; + myTypeText = TypeInfo.internFrequentType(typeText); + myVariance = variance; + myAnnotations = annotations; + myChild = new AtomicNullableLazyValue() { + @Override + protected ClsElementImpl compute() { + return calculateChild(); + } + }; + myCachedType = AtomicNotNullLazyValue.createValue(this::calculateType); + } - @Override - public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorException { - setMirrorCheckingType(element, JavaElementType.TYPE); + @Override + @Nonnull + public PsiElement[] getChildren() { + ClsElementImpl child = myChild.getValue(); + return child != null ? new PsiElement[]{child} : PsiElement.EMPTY_ARRAY; + } - ClsElementImpl child = myChild.getValue(); - if (child != null) { - child.setMirror(element.getFirstChildNode()); + @Override + public PsiElement getParent() { + return myParent; } - } - - private boolean isArray() { - return myTypeText.endsWith("[]"); - } - - private boolean isVarArgs() { - return myTypeText.endsWith("..."); - } - - @Override - @Nonnull - public PsiType getType() { - return myCachedType.getValue(); - } - - @Override - public PsiJavaCodeReferenceElement getInnermostComponentReferenceElement() { - return null; - } - - private ClsElementImpl calculateChild() { - if (PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText) != null) { - return null; + + @Override + public String getText() { + final String shortClassName = PsiNameHelper.getShortClassName(myTypeText); + return decorateTypeText(shortClassName); } - if (isArray()) { - if (myVariance == VARIANCE_NONE) { - return getDeepestArrayElement(); - } - return new ClsTypeElementImpl(this, myTypeText, VARIANCE_NONE, myAnnotations.forBound()); + + private String decorateTypeText(final String shortClassName) { + switch (myVariance) { + case VARIANCE_NONE: + return shortClassName; + case VARIANCE_EXTENDS: + return PsiWildcardType.EXTENDS_PREFIX + shortClassName; + case VARIANCE_SUPER: + return PsiWildcardType.SUPER_PREFIX + shortClassName; + case VARIANCE_INVARIANT: + return "?"; + default: + assert false : myVariance; + return null; + } } - if (isVarArgs()) { - return getDeepestArrayElement(); + + public String getCanonicalText() { + return decorateTypeText(myTypeText); } - return myVariance == VARIANCE_INVARIANT ? null : - new ClsJavaCodeReferenceElementImpl(this, myTypeText, myVariance == VARIANCE_NONE ? myAnnotations : myAnnotations.forBound()); - } - - int getArrayDepth() { - boolean varArgs = isVarArgs(); - if (!varArgs && !isArray()) { - return 0; + + @Override + public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { + buffer.append(getType().getCanonicalText(true)); } - int bracketPos = myTypeText.length() - (varArgs ? 3 : 2); - int depth = 1; - while (bracketPos > 2 && myTypeText.startsWith("[]", bracketPos - 2)) { - bracketPos -= 2; - depth++; + + @Override + public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorException { + setMirrorCheckingType(element, JavaElementType.TYPE); + + ClsElementImpl child = myChild.getValue(); + if (child != null) { + child.setMirror(element.getFirstChildNode()); + } } - return depth; - } - - @Nonnull - private ClsElementImpl getDeepestArrayElement() { - int depth = getArrayDepth(); - int bracketPos = myTypeText.length() - depth * 2 - (isVarArgs() ? 1 : 0); - TypeAnnotationContainer container = myAnnotations; - for (int i = 0; i < depth; i++) { - container = container.forArrayElement(); + + private boolean isArray() { + return myTypeText.endsWith("[]"); } - return new ClsTypeElementImpl(this, myTypeText.substring(0, bracketPos), myVariance, container); - } - - - @Nonnull - private PsiType createArrayType(PsiTypeElement deepestChild) { - int depth = getArrayDepth(); - List containers = - StreamEx.iterate(myAnnotations, TypeAnnotationContainer::forArrayElement).limit(depth).toList(); - PsiType type = deepestChild.getType(); - for (int i = depth - 1; i >= 0; i--) { - if (i == 0 && isVarArgs()) { - type = new PsiEllipsisType(type); - } else { - type = type.createArrayType(); - } - type = type.annotate(containers.get(i).getProvider(this)); + + private boolean isVarArgs() { + return myTypeText.endsWith("..."); } - return type; - } - - @Nonnull - private PsiType calculateType() { - return calculateBaseType().annotate(myAnnotations.getProvider(this)); - } - - @Nonnull - private PsiType calculateBaseType() { - PsiType result = PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText); - if (result != null) { - return result; + + @Override + @Nonnull + public PsiType getType() { + return myCachedType.getValue(); } - ClsElementImpl childElement = myChild.getValue(); - if (childElement instanceof ClsTypeElementImpl) { - if (isArray()) { - switch (myVariance) { - case VARIANCE_NONE: - return createArrayType((PsiTypeElement) childElement); - case VARIANCE_EXTENDS: - return PsiWildcardType.createExtends(getManager(), ((PsiTypeElement) childElement).getType()); - case VARIANCE_SUPER: - return PsiWildcardType.createSuper(getManager(), ((PsiTypeElement) childElement).getType()); - default: - assert false : myVariance; + @Override + public PsiJavaCodeReferenceElement getInnermostComponentReferenceElement() { + return null; + } + + private ClsElementImpl calculateChild() { + if (PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText) != null) { return null; } - } else { - assert isVarArgs() : this; - return createArrayType((PsiTypeElement) childElement); - } + if (isArray()) { + if (myVariance == VARIANCE_NONE) { + return getDeepestArrayElement(); + } + return new ClsTypeElementImpl(this, myTypeText, VARIANCE_NONE, myAnnotations.forBound()); + } + if (isVarArgs()) { + return getDeepestArrayElement(); + } + return myVariance == VARIANCE_INVARIANT ? null : + new ClsJavaCodeReferenceElementImpl(this, myTypeText, myVariance == VARIANCE_NONE ? myAnnotations : myAnnotations.forBound()); + } + + int getArrayDepth() { + boolean varArgs = isVarArgs(); + if (!varArgs && !isArray()) { + return 0; + } + int bracketPos = myTypeText.length() - (varArgs ? 3 : 2); + int depth = 1; + while (bracketPos > 2 && myTypeText.startsWith("[]", bracketPos - 2)) { + bracketPos -= 2; + depth++; + } + return depth; } - if (childElement instanceof ClsJavaCodeReferenceElementImpl) { - PsiClassReferenceType psiClassReferenceType = new PsiClassReferenceType((PsiJavaCodeReferenceElement) childElement, null); - switch (myVariance) { - case VARIANCE_NONE: - return psiClassReferenceType; - case VARIANCE_EXTENDS: - return PsiWildcardType.createExtends(getManager(), psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(childElement))); - case VARIANCE_SUPER: - return PsiWildcardType.createSuper(getManager(), psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(childElement))); - case VARIANCE_INVARIANT: - return PsiWildcardType.createUnbounded(getManager()); - default: - assert false : myVariance; - return null; - } + + @Nonnull + private ClsElementImpl getDeepestArrayElement() { + int depth = getArrayDepth(); + int bracketPos = myTypeText.length() - depth * 2 - (isVarArgs() ? 1 : 0); + TypeAnnotationContainer container = myAnnotations; + for (int i = 0; i < depth; i++) { + container = container.forArrayElement(); + } + return new ClsTypeElementImpl(this, myTypeText.substring(0, bracketPos), myVariance, container); + } + + + @Nonnull + private PsiType createArrayType(PsiTypeElement deepestChild) { + int depth = getArrayDepth(); + List containers = + StreamEx.iterate(myAnnotations, TypeAnnotationContainer::forArrayElement).limit(depth).toList(); + PsiType type = deepestChild.getType(); + for (int i = depth - 1; i >= 0; i--) { + if (i == 0 && isVarArgs()) { + type = new PsiEllipsisType(type); + } + else { + type = type.createArrayType(); + } + type = type.annotate(containers.get(i).getProvider(this)); + } + return type; + } + + @Nonnull + private PsiType calculateType() { + return calculateBaseType().annotate(myAnnotations.getProvider(this)); + } + + @Nonnull + private PsiType calculateBaseType() { + PsiType result = PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText); + if (result != null) { + return result; + } + + ClsElementImpl childElement = myChild.getValue(); + if (childElement instanceof ClsTypeElementImpl) { + if (isArray()) { + switch (myVariance) { + case VARIANCE_NONE: + return createArrayType((PsiTypeElement)childElement); + case VARIANCE_EXTENDS: + return PsiWildcardType.createExtends(getManager(), ((PsiTypeElement)childElement).getType()); + case VARIANCE_SUPER: + return PsiWildcardType.createSuper(getManager(), ((PsiTypeElement)childElement).getType()); + default: + assert false : myVariance; + return null; + } + } + else { + assert isVarArgs() : this; + return createArrayType((PsiTypeElement)childElement); + } + } + if (childElement instanceof ClsJavaCodeReferenceElementImpl) { + PsiClassReferenceType psiClassReferenceType = new PsiClassReferenceType((PsiJavaCodeReferenceElement)childElement, null); + switch (myVariance) { + case VARIANCE_NONE: + return psiClassReferenceType; + case VARIANCE_EXTENDS: + return PsiWildcardType.createExtends( + getManager(), + psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(childElement)) + ); + case VARIANCE_SUPER: + return PsiWildcardType.createSuper( + getManager(), + psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(childElement)) + ); + case VARIANCE_INVARIANT: + return PsiWildcardType.createUnbounded(getManager()); + default: + assert false : myVariance; + return null; + } + } + assert childElement == null : this; + return PsiWildcardType.createUnbounded(getManager()); } - assert childElement == null : this; - return PsiWildcardType.createUnbounded(getManager()); - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor) visitor).visitTypeElement(this); - } else { - visitor.visitElement(this); + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeElement(this); + } + else { + visitor.visitElement(this); + } + } + + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + throw new UnsupportedOperationException();//todo + } + + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + return PsiImplUtil.findAnnotation(this, qualifiedName); + } + + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { + throw new UnsupportedOperationException(); + } + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getType().getAnnotations(); + } + + @Override + public String toString() { + return "PsiTypeElement:" + getText(); } - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - throw new UnsupportedOperationException();//todo - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - return PsiImplUtil.findAnnotation(this, qualifiedName); - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { - throw new UnsupportedOperationException(); - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getType().getAnnotations(); - } - - @Override - public String toString() { - return "PsiTypeElement:" + getText(); - } } \ No newline at end of file diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java index 270ecdfb39..53a8e71aa6 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java @@ -39,6 +39,7 @@ import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.List; @@ -46,346 +47,362 @@ * @author max */ public class ClsTypeParameterImpl extends ClsRepositoryPsiElement implements PsiTypeParameter, PsiMetaOwner { - private final LightEmptyImplementsList myLightEmptyImplementsList; - - public ClsTypeParameterImpl(@Nonnull PsiTypeParameterStub stub) { - super(stub); - myLightEmptyImplementsList = new LightEmptyImplementsList(getManager()); - } - - @Override - public String getQualifiedName() { - return null; - } - - @Override - public boolean isInterface() { - return false; - } - - @Override - public boolean isAnnotationType() { - return false; - } - - @Override - public boolean isEnum() { - return false; - } - - @Override - @Nonnull - public PsiField[] getFields() { - return PsiField.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiMethod[] getMethods() { - return PsiMethod.EMPTY_ARRAY; - } - - @Override - public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) { - return PsiClassImplUtil.findMethodBySignature(this, patternMethod, checkBases); - } - - @Override - @Nonnull - public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) { - return PsiClassImplUtil.findMethodsBySignature(this, patternMethod, checkBases); - } - - @Override - public PsiField findFieldByName(String name, boolean checkBases) { - return PsiClassImplUtil.findFieldByName(this, name, checkBases); - } - - @Override - @Nonnull - public PsiMethod[] findMethodsByName(String name, boolean checkBases) { - return PsiClassImplUtil.findMethodsByName(this, name, checkBases); - } - - @Override - @Nonnull - public List> findMethodsAndTheirSubstitutorsByName(String name, boolean checkBases) { - return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); - } - - @Override - @Nonnull - public List> getAllMethodsAndTheirSubstitutors() { - return PsiClassImplUtil.getAllWithSubstitutorsByMap(this, PsiClassImplUtil.MemberType.METHOD); - } - - @Override - public PsiClass findInnerClassByName(String name, boolean checkBases) { - return PsiClassImplUtil.findInnerByName(this, name, checkBases); - } - - @Override - public PsiTypeParameterList getTypeParameterList() { - return null; - } - - @Override - public boolean hasTypeParameters() { - return false; - } - - // very special method! - @Override - public PsiElement getScope() { - return getParent().getParent(); - } - - @Override - public boolean isInheritorDeep(PsiClass baseClass, PsiClass classToByPass) { - return InheritanceImplUtil.isInheritorDeep(this, baseClass, classToByPass); - } - - @Override - public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { - return InheritanceImplUtil.isInheritor(this, baseClass, checkDeep); - } - - @Override - public PsiIdentifier getNameIdentifier() { - return null; - } - - @Override - public boolean processDeclarations(@Nonnull PsiScopeProcessor processor, @Nonnull ResolveState state, PsiElement lastParent, @Nonnull PsiElement place) { - return PsiClassImplUtil.processDeclarationsInClass(this, processor, state, null, lastParent, place, PsiUtil.getLanguageLevel(place), false); - } - - @Override - public String getName() { - return getStub().getName(); - } - - @Override - public PsiElement setName(@Nonnull String name) throws IncorrectOperationException { - throw new IncorrectOperationException("Cannot change compiled classes"); - } - - @Override - @Nonnull - public PsiMethod[] getConstructors() { - return PsiMethod.EMPTY_ARRAY; - } - - @Override - public PsiDocComment getDocComment() { - return null; - } - - @Override - public boolean isDeprecated() { - return false; - } - - @Override - @Nonnull - public PsiReferenceList getExtendsList() { - return getStub().findChildStubByType(JavaStubElementTypes.EXTENDS_BOUND_LIST).getPsi(); - } - - @Override - public PsiReferenceList getImplementsList() { - return myLightEmptyImplementsList; - } - - @Override - @Nonnull - public PsiClassType[] getExtendsListTypes() { - return getExtendsList().getReferencedTypes(); - } - - @Override - @Nonnull - public PsiClassType[] getImplementsListTypes() { - return PsiClassType.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiClass[] getInnerClasses() { - return PsiClass.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiField[] getAllFields() { - return PsiField.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiMethod[] getAllMethods() { - return PsiMethod.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiClass[] getAllInnerClasses() { - return PsiClass.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiClassInitializer[] getInitializers() { - return PsiClassInitializer.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiTypeParameter[] getTypeParameters() { - return PsiTypeParameter.EMPTY_ARRAY; - } - - @Override - public PsiClass getSuperClass() { - return PsiClassImplUtil.getSuperClass(this); - } - - @Override - public PsiClass[] getInterfaces() { - return PsiClassImplUtil.getInterfaces(this); - } - - @Override - @Nonnull - public PsiClass[] getSupers() { - return PsiClassImplUtil.getSupers(this); - } - - @Override - @Nonnull - public PsiClassType[] getSuperTypes() { - return PsiClassImplUtil.getSuperTypes(this); - } - - @Override - public PsiClass getContainingClass() { - return null; - } - - @Override - @Nonnull - public Collection getVisibleSignatures() { - return PsiSuperMethodImplUtil.getVisibleSignatures(this); - } - - @Override - public PsiModifierList getModifierList() { - return null; - } - - @Override - public boolean hasModifierProperty(@Nonnull String name) { - return false; - } - - @Override - public PsiJavaToken getLBrace() { - return null; - } - - @Override - public PsiJavaToken getRBrace() { - return null; - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); - } - else { - visitor.visitElement(this); - } - } - - @NonNls - public String toString() { - return "PsiTypeParameter"; - } - - @Override - public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { - buffer.append(getName()); - - PsiJavaCodeReferenceElement[] bounds = getExtendsList().getReferenceElements(); - if (bounds.length > 0) { - buffer.append(" extends "); - for (int i = 0; i < bounds.length; i++) { - if (i > 0) buffer.append(" & "); - buffer.append(bounds[i].getCanonicalText()); - } - } - } - - @Override - public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorException { - setMirrorCheckingType(element, null); - setMirror(getExtendsList(), SourceTreeToPsiMap.treeToPsiNotNull(element).getExtendsList()); - } - - @Override - @Nonnull - public PsiElement[] getChildren() { - return PsiElement.EMPTY_ARRAY; - } - - @Override - public PsiTypeParameterListOwner getOwner() { - return (PsiTypeParameterListOwner)getParent().getParent(); - } - - @Override - public int getIndex() { - final PsiTypeParameterStub stub = getStub(); - return stub.getParentStub().getChildrenStubs().indexOf(stub); - } - - public PsiMetaData getMetaData() { - return MetaDataService.getInstance().getMeta(this); - } - - @Override - public boolean isEquivalentTo(final PsiElement another) { - return PsiClassImplUtil.isClassEquivalentTo(this, another); - } - - @Override - @Nonnull - public SearchScope getUseScope() { - return PsiClassImplUtil.getClassUseScope(this); - } - - //todo parse annotataions - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - return PsiAnnotation.EMPTY_ARRAY; - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { - return null; - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { - throw new IncorrectOperationException(); - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getAnnotations(); - } + private final LightEmptyImplementsList myLightEmptyImplementsList; + + public ClsTypeParameterImpl(@Nonnull PsiTypeParameterStub stub) { + super(stub); + myLightEmptyImplementsList = new LightEmptyImplementsList(getManager()); + } + + @Override + public String getQualifiedName() { + return null; + } + + @Override + public boolean isInterface() { + return false; + } + + @Override + public boolean isAnnotationType() { + return false; + } + + @Override + public boolean isEnum() { + return false; + } + + @Override + @Nonnull + public PsiField[] getFields() { + return PsiField.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiMethod[] getMethods() { + return PsiMethod.EMPTY_ARRAY; + } + + @Override + public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) { + return PsiClassImplUtil.findMethodBySignature(this, patternMethod, checkBases); + } + + @Override + @Nonnull + public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) { + return PsiClassImplUtil.findMethodsBySignature(this, patternMethod, checkBases); + } + + @Override + public PsiField findFieldByName(String name, boolean checkBases) { + return PsiClassImplUtil.findFieldByName(this, name, checkBases); + } + + @Override + @Nonnull + public PsiMethod[] findMethodsByName(String name, boolean checkBases) { + return PsiClassImplUtil.findMethodsByName(this, name, checkBases); + } + + @Override + @Nonnull + public List> findMethodsAndTheirSubstitutorsByName(String name, boolean checkBases) { + return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); + } + + @Override + @Nonnull + public List> getAllMethodsAndTheirSubstitutors() { + return PsiClassImplUtil.getAllWithSubstitutorsByMap(this, PsiClassImplUtil.MemberType.METHOD); + } + + @Override + public PsiClass findInnerClassByName(String name, boolean checkBases) { + return PsiClassImplUtil.findInnerByName(this, name, checkBases); + } + + @Override + public PsiTypeParameterList getTypeParameterList() { + return null; + } + + @Override + public boolean hasTypeParameters() { + return false; + } + + // very special method! + @Override + public PsiElement getScope() { + return getParent().getParent(); + } + + @Override + public boolean isInheritorDeep(PsiClass baseClass, PsiClass classToByPass) { + return InheritanceImplUtil.isInheritorDeep(this, baseClass, classToByPass); + } + + @Override + public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { + return InheritanceImplUtil.isInheritor(this, baseClass, checkDeep); + } + + @Override + public PsiIdentifier getNameIdentifier() { + return null; + } + + @Override + public boolean processDeclarations( + @Nonnull PsiScopeProcessor processor, + @Nonnull ResolveState state, + PsiElement lastParent, + @Nonnull PsiElement place + ) { + return PsiClassImplUtil.processDeclarationsInClass( + this, + processor, + state, + null, + lastParent, + place, + PsiUtil.getLanguageLevel(place), + false + ); + } + + @Override + public String getName() { + return getStub().getName(); + } + + @Override + public PsiElement setName(@Nonnull String name) throws IncorrectOperationException { + throw new IncorrectOperationException("Cannot change compiled classes"); + } + + @Override + @Nonnull + public PsiMethod[] getConstructors() { + return PsiMethod.EMPTY_ARRAY; + } + + @Override + public PsiDocComment getDocComment() { + return null; + } + + @Override + public boolean isDeprecated() { + return false; + } + + @Override + @Nonnull + public PsiReferenceList getExtendsList() { + return getStub().findChildStubByType(JavaStubElementTypes.EXTENDS_BOUND_LIST).getPsi(); + } + + @Override + public PsiReferenceList getImplementsList() { + return myLightEmptyImplementsList; + } + + @Override + @Nonnull + public PsiClassType[] getExtendsListTypes() { + return getExtendsList().getReferencedTypes(); + } + + @Override + @Nonnull + public PsiClassType[] getImplementsListTypes() { + return PsiClassType.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiClass[] getInnerClasses() { + return PsiClass.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiField[] getAllFields() { + return PsiField.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiMethod[] getAllMethods() { + return PsiMethod.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiClass[] getAllInnerClasses() { + return PsiClass.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiClassInitializer[] getInitializers() { + return PsiClassInitializer.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiTypeParameter[] getTypeParameters() { + return PsiTypeParameter.EMPTY_ARRAY; + } + + @Override + public PsiClass getSuperClass() { + return PsiClassImplUtil.getSuperClass(this); + } + + @Override + public PsiClass[] getInterfaces() { + return PsiClassImplUtil.getInterfaces(this); + } + + @Override + @Nonnull + public PsiClass[] getSupers() { + return PsiClassImplUtil.getSupers(this); + } + + @Override + @Nonnull + public PsiClassType[] getSuperTypes() { + return PsiClassImplUtil.getSuperTypes(this); + } + + @Override + public PsiClass getContainingClass() { + return null; + } + + @Override + @Nonnull + public Collection getVisibleSignatures() { + return PsiSuperMethodImplUtil.getVisibleSignatures(this); + } + + @Override + public PsiModifierList getModifierList() { + return null; + } + + @Override + public boolean hasModifierProperty(@Nonnull String name) { + return false; + } + + @Override + public PsiJavaToken getLBrace() { + return null; + } + + @Override + public PsiJavaToken getRBrace() { + return null; + } + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeParameter(this); + } + else { + visitor.visitElement(this); + } + } + + @NonNls + public String toString() { + return "PsiTypeParameter"; + } + + @Override + public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { + buffer.append(getName()); + + PsiJavaCodeReferenceElement[] bounds = getExtendsList().getReferenceElements(); + if (bounds.length > 0) { + buffer.append(" extends "); + for (int i = 0; i < bounds.length; i++) { + if (i > 0) { + buffer.append(" & "); + } + buffer.append(bounds[i].getCanonicalText()); + } + } + } + + @Override + public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorException { + setMirrorCheckingType(element, null); + setMirror(getExtendsList(), SourceTreeToPsiMap.treeToPsiNotNull(element).getExtendsList()); + } + + @Override + @Nonnull + public PsiElement[] getChildren() { + return PsiElement.EMPTY_ARRAY; + } + + @Override + public PsiTypeParameterListOwner getOwner() { + return (PsiTypeParameterListOwner)getParent().getParent(); + } + + @Override + public int getIndex() { + final PsiTypeParameterStub stub = getStub(); + return stub.getParentStub().getChildrenStubs().indexOf(stub); + } + + public PsiMetaData getMetaData() { + return MetaDataService.getInstance().getMeta(this); + } + + @Override + public boolean isEquivalentTo(final PsiElement another) { + return PsiClassImplUtil.isClassEquivalentTo(this, another); + } + + @Override + @Nonnull + public SearchScope getUseScope() { + return PsiClassImplUtil.getClassUseScope(this); + } + + //todo parse annotataions + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + return PsiAnnotation.EMPTY_ARRAY; + } + + @Override + public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { + return null; + } + + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + throw new IncorrectOperationException(); + } + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getAnnotations(); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java index afb39bc6e5..f2703b95c7 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java @@ -26,101 +26,105 @@ import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; + import java.util.HashSet; import java.util.Set; public class LightModifierList extends LightElement implements PsiModifierList { - private final Set myModifiers; - - public LightModifierList(PsiModifierListOwner modifierListOwner) { - this(modifierListOwner.getManager()); - copyModifiers(modifierListOwner.getModifierList()); - } - - public LightModifierList(PsiManager manager) { - this(manager, JavaLanguage.INSTANCE); - } - - public LightModifierList(PsiManager manager, final Language language, String... modifiers) { - super(manager, language); - myModifiers = new HashSet<>(Set.of(modifiers)); - } - - public void addModifier(String modifier) { - myModifiers.add(modifier); - } - - public void copyModifiers(PsiModifierList modifierList) { - if (modifierList == null) return; - for (String modifier : PsiModifier.MODIFIERS) { - if (modifierList.hasExplicitModifier(modifier)) { - addModifier(modifier); - } - } - } - - public void clearModifiers() { - myModifiers.clear(); - } - - @Override - public boolean hasModifierProperty(@Nonnull String name) { - return myModifiers.contains(name); - } - - @Override - public boolean hasExplicitModifier(@Nonnull String name) { - return myModifiers.contains(name); - } - - @Override - public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { - throw new IncorrectOperationException(); - } - - @Override - public void checkSetModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { - throw new IncorrectOperationException(); - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - //todo - return PsiAnnotation.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getAnnotations(); - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - return null; - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { - throw new IncorrectOperationException(); - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor) visitor).visitModifierList(this); - } else { - visitor.visitElement(this); - } - } - - public String toString() { - return "PsiModifierList"; - } - - public String[] getModifiers() { - return ArrayUtil.toStringArray(myModifiers); - } + private final Set myModifiers; + + public LightModifierList(PsiModifierListOwner modifierListOwner) { + this(modifierListOwner.getManager()); + copyModifiers(modifierListOwner.getModifierList()); + } + + public LightModifierList(PsiManager manager) { + this(manager, JavaLanguage.INSTANCE); + } + + public LightModifierList(PsiManager manager, final Language language, String... modifiers) { + super(manager, language); + myModifiers = new HashSet<>(Set.of(modifiers)); + } + + public void addModifier(String modifier) { + myModifiers.add(modifier); + } + + public void copyModifiers(PsiModifierList modifierList) { + if (modifierList == null) { + return; + } + for (String modifier : PsiModifier.MODIFIERS) { + if (modifierList.hasExplicitModifier(modifier)) { + addModifier(modifier); + } + } + } + + public void clearModifiers() { + myModifiers.clear(); + } + + @Override + public boolean hasModifierProperty(@Nonnull String name) { + return myModifiers.contains(name); + } + + @Override + public boolean hasExplicitModifier(@Nonnull String name) { + return myModifiers.contains(name); + } + + @Override + public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { + throw new IncorrectOperationException(); + } + + @Override + public void checkSetModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { + throw new IncorrectOperationException(); + } + + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + //todo + return PsiAnnotation.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getAnnotations(); + } + + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + return null; + } + + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + throw new IncorrectOperationException(); + } + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitModifierList(this); + } + else { + visitor.visitElement(this); + } + } + + public String toString() { + return "PsiModifierList"; + } + + public String[] getModifiers() { + return ArrayUtil.toStringArray(myModifiers); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java index 196d4617fc..fbc8714976 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java @@ -31,74 +31,74 @@ * @author max */ public class LightTypeElement extends LightElement implements PsiTypeElement { - private final PsiType myType; + private final PsiType myType; - public LightTypeElement(PsiManager manager, PsiType type) { - super(manager, JavaLanguage.INSTANCE); - type = PsiUtil.convertAnonymousToBaseType(type); - myType = type; - } - - public String toString() { - return "PsiTypeElement:" + getText(); - } + public LightTypeElement(PsiManager manager, PsiType type) { + super(manager, JavaLanguage.INSTANCE); + type = PsiUtil.convertAnonymousToBaseType(type); + myType = type; + } - @Override - public String getText() { - return myType.getPresentableText(); - } + public String toString() { + return "PsiTypeElement:" + getText(); + } - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor) visitor).visitTypeElement(this); - } else { - visitor.visitElement(this); + @Override + public String getText() { + return myType.getPresentableText(); } - } - @Override - public PsiElement copy() { - return new LightTypeElement(myManager, myType); - } + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeElement(this); + } + else { + visitor.visitElement(this); + } + } - @Override - @Nonnull - public PsiType getType() { - return myType; - } + @Override + public PsiElement copy() { + return new LightTypeElement(myManager, myType); + } - @Override - public PsiJavaCodeReferenceElement getInnermostComponentReferenceElement() { - return null; - } + @Override + @Nonnull + public PsiType getType() { + return myType; + } - @Override - public boolean isValid() { - return myType.isValid(); - } + @Override + public PsiJavaCodeReferenceElement getInnermostComponentReferenceElement() { + return null; + } - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - return myType.getAnnotations(); - } + @Override + public boolean isValid() { + return myType.isValid(); + } - @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { - return myType.findAnnotation(qualifiedName); - } + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + return myType.getAnnotations(); + } - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { - throw new IncorrectOperationException(); - } + @Override + public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { + return myType.findAnnotation(qualifiedName); + } - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getAnnotations(); - } + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + throw new IncorrectOperationException(); + } + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getAnnotations(); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java index 0fb41065c8..68edd18731 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java @@ -25,71 +25,71 @@ import org.jetbrains.annotations.NonNls; public class LightTypeParameter extends LightClass implements PsiTypeParameter { - public LightTypeParameter(final PsiTypeParameter delegate) { - super(delegate); - } - - @Nonnull - @Override - public PsiTypeParameter getDelegate() { - return (PsiTypeParameter)super.getDelegate(); - } + public LightTypeParameter(final PsiTypeParameter delegate) { + super(delegate); + } - @Nonnull - @Override - public PsiElement copy() { - return new LightTypeParameter(getDelegate()); - } + @Nonnull + @Override + public PsiTypeParameter getDelegate() { + return (PsiTypeParameter)super.getDelegate(); + } - @Override - public void accept(@Nonnull final PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); + @Nonnull + @Override + public PsiElement copy() { + return new LightTypeParameter(getDelegate()); } - else { - super.accept(visitor); + + @Override + public void accept(@Nonnull final PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeParameter(this); + } + else { + super.accept(visitor); + } } - } - @Override - public PsiTypeParameterListOwner getOwner() { - return getDelegate().getOwner(); - } + @Override + public PsiTypeParameterListOwner getOwner() { + return getDelegate().getOwner(); + } - @Override - public int getIndex() { - return getDelegate().getIndex(); - } + @Override + public int getIndex() { + return getDelegate().getIndex(); + } - @Nonnull - @Override - public PsiAnnotation[] getAnnotations() { - return getDelegate().getAnnotations(); - } + @Nonnull + @Override + public PsiAnnotation[] getAnnotations() { + return getDelegate().getAnnotations(); + } - @Nonnull - @Override - public PsiAnnotation[] getApplicableAnnotations() { - return getDelegate().getApplicableAnnotations(); - } + @Nonnull + @Override + public PsiAnnotation[] getApplicableAnnotations() { + return getDelegate().getApplicableAnnotations(); + } - @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls final String qualifiedName) { - return getDelegate().findAnnotation(qualifiedName); - } + @Override + public PsiAnnotation findAnnotation(@Nonnull @NonNls final String qualifiedName) { + return getDelegate().findAnnotation(qualifiedName); + } - @Nonnull - @Override - public PsiAnnotation addAnnotation(@Nonnull @NonNls final String qualifiedName) { - return getDelegate().addAnnotation(qualifiedName); - } + @Nonnull + @Override + public PsiAnnotation addAnnotation(@Nonnull @NonNls final String qualifiedName) { + return getDelegate().addAnnotation(qualifiedName); + } - public boolean useDelegateToSubstitute() { - return true; - } + public boolean useDelegateToSubstitute() { + return true; + } - @Override - public String toString() { - return "PsiTypeParameter:" + getName(); - } + @Override + public String toString() { + return "PsiTypeParameter:" + getName(); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java index 48bcd32543..a9423f9f18 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java @@ -11,57 +11,57 @@ public class LightTypeParameterBuilder extends LightPsiClassBuilder implements PsiTypeParameter { - private final PsiTypeParameterListOwner myOwner; - private final int myIndex; + private final PsiTypeParameterListOwner myOwner; + private final int myIndex; - public LightTypeParameterBuilder(@Nonnull String name, PsiTypeParameterListOwner owner, int index) { - super(owner, name); - myOwner = owner; - myIndex = index; - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); + public LightTypeParameterBuilder(@Nonnull String name, PsiTypeParameterListOwner owner, int index) { + super(owner, name); + myOwner = owner; + myIndex = index; } - else { - visitor.visitElement(this); + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeParameter(this); + } + else { + visitor.visitElement(this); + } } - } - @Nullable - @Override - public PsiTypeParameterListOwner getOwner() { - return myOwner; - } + @Nullable + @Override + public PsiTypeParameterListOwner getOwner() { + return myOwner; + } - @Override - public int getIndex() { - return myIndex; - } + @Override + public int getIndex() { + return myIndex; + } - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - return getModifierList().getAnnotations(); - } + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + return getModifierList().getAnnotations(); + } - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getModifierList().getApplicableAnnotations(); - } + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getModifierList().getApplicableAnnotations(); + } - @Nullable - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - return getModifierList().findAnnotation(qualifiedName); - } + @Nullable + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + return getModifierList().findAnnotation(qualifiedName); + } - @Nonnull - @Override - public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { - return getModifierList().addAnnotation(qualifiedName); - } + @Nonnull + @Override + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { + return getModifierList().addAnnotation(qualifiedName); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/JavaStubPsiElement.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/JavaStubPsiElement.java index 23f64866cd..817fe33549 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/JavaStubPsiElement.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/JavaStubPsiElement.java @@ -13,216 +13,219 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/* - * @author max - */ package com.intellij.java.language.impl.psi.impl.source; -import consulo.language.impl.psi.stub.StubBasedPsiElementBase; -import consulo.language.psi.PsiNavigationSupport; import com.intellij.java.language.JavaLanguage; -import consulo.language.ast.ASTNode; +import consulo.annotation.access.RequiredReadAction; import consulo.language.Language; -import consulo.navigation.Navigatable; -import consulo.language.psi.PsiElement; -import consulo.language.psi.PsiElementVisitor; -import consulo.language.psi.StubBasedPsiElement; -import consulo.language.impl.psi.CheckUtil; -import consulo.language.impl.psi.SourceTreeToPsiMap; -import consulo.language.impl.psi.CodeEditUtil; +import consulo.language.ast.ASTNode; import consulo.language.impl.ast.ChangeUtil; import consulo.language.impl.ast.CompositeElement; import consulo.language.impl.ast.SharedImplUtil; import consulo.language.impl.ast.TreeElement; +import consulo.language.impl.psi.CheckUtil; +import consulo.language.impl.psi.CodeEditUtil; +import consulo.language.impl.psi.SourceTreeToPsiMap; +import consulo.language.impl.psi.stub.StubBasedPsiElementBase; +import consulo.language.psi.PsiElement; +import consulo.language.psi.PsiElementVisitor; +import consulo.language.psi.PsiNavigationSupport; +import consulo.language.psi.StubBasedPsiElement; import consulo.language.psi.stub.IStubElementType; import consulo.language.psi.stub.StubElement; import consulo.language.util.IncorrectOperationException; -import consulo.annotation.access.RequiredReadAction; import consulo.logging.Logger; - +import consulo.navigation.Navigatable; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; +/** + * @author max + */ public abstract class JavaStubPsiElement extends StubBasedPsiElementBase implements StubBasedPsiElement { - private static final Logger LOG = Logger.getInstance(JavaStubPsiElement.class); - - public JavaStubPsiElement(@Nonnull T stub, @Nonnull IStubElementType nodeType) { - super(stub, nodeType); - } - - public JavaStubPsiElement(@Nonnull ASTNode node) { - super(node); - } - - @RequiredReadAction - @Override - @Nonnull - public Language getLanguage() { - return JavaLanguage.INSTANCE; - } - - @RequiredReadAction - @Override - public int getTextOffset() { - return calcTreeElement().getTextOffset(); - } - - @RequiredReadAction - protected CompositeElement calcTreeElement() { - return (CompositeElement) getNode(); - } - - @Override - public PsiElement add(@Nonnull PsiElement element) throws IncorrectOperationException { - CheckUtil.checkWritable(this); - TreeElement elementCopy = ChangeUtil.copyToElement(element); - calcTreeElement().addInternal(elementCopy, elementCopy, null, null); - elementCopy = ChangeUtil.decodeInformation(elementCopy); - return SourceTreeToPsiMap.treeElementToPsi(elementCopy); - } - - @Override - public PsiElement addBefore(@Nonnull PsiElement element, PsiElement anchor) throws IncorrectOperationException { - CheckUtil.checkWritable(this); - TreeElement elementCopy = ChangeUtil.copyToElement(element); - calcTreeElement().addInternal(elementCopy, elementCopy, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.TRUE); - elementCopy = ChangeUtil.decodeInformation(elementCopy); - return SourceTreeToPsiMap.treeElementToPsi(elementCopy); - } - - @Override - public PsiElement addAfter(@Nonnull PsiElement element, @Nullable PsiElement anchor) throws IncorrectOperationException { - CheckUtil.checkWritable(this); - TreeElement elementCopy = ChangeUtil.copyToElement(element); - calcTreeElement().addInternal(elementCopy, elementCopy, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.FALSE); - elementCopy = ChangeUtil.decodeInformation(elementCopy); - return SourceTreeToPsiMap.treeElementToPsi(elementCopy); - } - - @Override - public final void checkAdd(@Nonnull PsiElement element) throws IncorrectOperationException { - CheckUtil.checkWritable(this); - } - - @Override - public PsiElement addRange(PsiElement first, PsiElement last) throws IncorrectOperationException { - return SharedImplUtil.addRange(this, first, last, null, null); - } - - @Override - public PsiElement addRangeBefore(@Nonnull PsiElement first, @Nonnull PsiElement last, PsiElement anchor) throws IncorrectOperationException { - return SharedImplUtil.addRange(this, first, last, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.TRUE); - } - - @Override - public PsiElement addRangeAfter(PsiElement first, PsiElement last, PsiElement anchor) throws IncorrectOperationException { - return SharedImplUtil.addRange(this, first, last, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.FALSE); - } - - @Override - public void delete() throws IncorrectOperationException { - ASTNode treeElement = calcTreeElement(); - LOG.assertTrue(treeElement.getTreeParent() != null); - CheckUtil.checkWritable(this); - ((CompositeElement) treeElement.getTreeParent()).deleteChildInternal(treeElement); - } - - @Override - public void deleteChildRange(PsiElement first, PsiElement last) throws IncorrectOperationException { - CheckUtil.checkWritable(this); - if (first == null) { - LOG.assertTrue(last == null); - return; - } - ASTNode firstElement = SourceTreeToPsiMap.psiElementToTree(first); - ASTNode lastElement = SourceTreeToPsiMap.psiElementToTree(last); - CompositeElement treeElement = calcTreeElement(); - LOG.assertTrue(firstElement.getTreeParent() == treeElement); - LOG.assertTrue(lastElement.getTreeParent() == treeElement); - CodeEditUtil.removeChildren(treeElement, firstElement, lastElement); - } - - @Override - public PsiElement replace(@Nonnull PsiElement newElement) throws IncorrectOperationException { - CompositeElement treeElement = calcTreeElement(); - return SharedImplUtil.doReplace(this, treeElement, newElement); - } - - @Override - public void navigate(boolean requestFocus) { - final Navigatable navigatable = PsiNavigationSupport.getInstance().getDescriptor(this); - if (navigatable != null) { - navigatable.navigate(requestFocus); - } - } - - @Override - public boolean canNavigate() { - return PsiNavigationSupport.getInstance().canNavigate(this); - } - - @Override - public boolean canNavigateToSource() { - return canNavigate(); - } - - @Override - public void acceptChildren(@Nonnull PsiElementVisitor visitor) { - SharedImplUtil.acceptChildren(visitor, calcTreeElement()); - } - - @Override - protected Object clone() { - CompositeElement treeElement = calcTreeElement(); - CompositeElement treeElementClone = (CompositeElement) (treeElement.getTreeParent() != null ? treeElement.copyElement() : (ASTNode) treeElement.clone()); - /* - if (treeElementClone.getPsiElement() != null) { - return treeElementClone.getPsiElement(); - } - */ - return cloneImpl(treeElementClone); - } - - protected StubBasedPsiElementBase cloneImpl(@Nonnull CompositeElement treeElementClone) { - StubBasedPsiElementBase clone = (StubBasedPsiElementBase) super.clone(); - clone.setNode(treeElementClone); - treeElementClone.setPsi(clone); - return clone; - } - - @Override - public void subtreeChanged() { - final CompositeElement compositeElement = calcTreeElement(); - if (compositeElement != null) { - compositeElement.clearCaches(); - } - super.subtreeChanged(); - } - - @RequiredReadAction - @Override - @Nonnull - public PsiElement[] getChildren() { - PsiElement psiChild = getFirstChild(); - if (psiChild == null) { - return PsiElement.EMPTY_ARRAY; - } - - int count = 0; - while (psiChild != null) { - count++; - psiChild = psiChild.getNextSibling(); - } - - PsiElement[] answer = new PsiElement[count]; - count = 0; - psiChild = getFirstChild(); - while (psiChild != null) { - answer[count++] = psiChild; - psiChild = psiChild.getNextSibling(); - } - - return answer; - } + private static final Logger LOG = Logger.getInstance(JavaStubPsiElement.class); + + public JavaStubPsiElement(@Nonnull T stub, @Nonnull IStubElementType nodeType) { + super(stub, nodeType); + } + + public JavaStubPsiElement(@Nonnull ASTNode node) { + super(node); + } + + @RequiredReadAction + @Override + @Nonnull + public Language getLanguage() { + return JavaLanguage.INSTANCE; + } + + @RequiredReadAction + @Override + public int getTextOffset() { + return calcTreeElement().getTextOffset(); + } + + @RequiredReadAction + protected CompositeElement calcTreeElement() { + return (CompositeElement)getNode(); + } + + @Override + public PsiElement add(@Nonnull PsiElement element) throws IncorrectOperationException { + CheckUtil.checkWritable(this); + TreeElement elementCopy = ChangeUtil.copyToElement(element); + calcTreeElement().addInternal(elementCopy, elementCopy, null, null); + elementCopy = ChangeUtil.decodeInformation(elementCopy); + return SourceTreeToPsiMap.treeElementToPsi(elementCopy); + } + + @Override + public PsiElement addBefore(@Nonnull PsiElement element, PsiElement anchor) throws IncorrectOperationException { + CheckUtil.checkWritable(this); + TreeElement elementCopy = ChangeUtil.copyToElement(element); + calcTreeElement().addInternal(elementCopy, elementCopy, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.TRUE); + elementCopy = ChangeUtil.decodeInformation(elementCopy); + return SourceTreeToPsiMap.treeElementToPsi(elementCopy); + } + + @Override + public PsiElement addAfter(@Nonnull PsiElement element, @Nullable PsiElement anchor) throws IncorrectOperationException { + CheckUtil.checkWritable(this); + TreeElement elementCopy = ChangeUtil.copyToElement(element); + calcTreeElement().addInternal(elementCopy, elementCopy, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.FALSE); + elementCopy = ChangeUtil.decodeInformation(elementCopy); + return SourceTreeToPsiMap.treeElementToPsi(elementCopy); + } + + @Override + public final void checkAdd(@Nonnull PsiElement element) throws IncorrectOperationException { + CheckUtil.checkWritable(this); + } + + @Override + public PsiElement addRange(PsiElement first, PsiElement last) throws IncorrectOperationException { + return SharedImplUtil.addRange(this, first, last, null, null); + } + + @Override + public PsiElement addRangeBefore( + @Nonnull PsiElement first, + @Nonnull PsiElement last, + PsiElement anchor + ) throws IncorrectOperationException { + return SharedImplUtil.addRange(this, first, last, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.TRUE); + } + + @Override + public PsiElement addRangeAfter(PsiElement first, PsiElement last, PsiElement anchor) throws IncorrectOperationException { + return SharedImplUtil.addRange(this, first, last, SourceTreeToPsiMap.psiElementToTree(anchor), Boolean.FALSE); + } + + @Override + public void delete() throws IncorrectOperationException { + ASTNode treeElement = calcTreeElement(); + LOG.assertTrue(treeElement.getTreeParent() != null); + CheckUtil.checkWritable(this); + ((CompositeElement)treeElement.getTreeParent()).deleteChildInternal(treeElement); + } + + @Override + public void deleteChildRange(PsiElement first, PsiElement last) throws IncorrectOperationException { + CheckUtil.checkWritable(this); + if (first == null) { + LOG.assertTrue(last == null); + return; + } + ASTNode firstElement = SourceTreeToPsiMap.psiElementToTree(first); + ASTNode lastElement = SourceTreeToPsiMap.psiElementToTree(last); + CompositeElement treeElement = calcTreeElement(); + LOG.assertTrue(firstElement.getTreeParent() == treeElement); + LOG.assertTrue(lastElement.getTreeParent() == treeElement); + CodeEditUtil.removeChildren(treeElement, firstElement, lastElement); + } + + @Override + public PsiElement replace(@Nonnull PsiElement newElement) throws IncorrectOperationException { + CompositeElement treeElement = calcTreeElement(); + return SharedImplUtil.doReplace(this, treeElement, newElement); + } + + @Override + public void navigate(boolean requestFocus) { + final Navigatable navigatable = PsiNavigationSupport.getInstance().getDescriptor(this); + if (navigatable != null) { + navigatable.navigate(requestFocus); + } + } + + @Override + public boolean canNavigate() { + return PsiNavigationSupport.getInstance().canNavigate(this); + } + + @Override + public boolean canNavigateToSource() { + return canNavigate(); + } + + @Override + public void acceptChildren(@Nonnull PsiElementVisitor visitor) { + SharedImplUtil.acceptChildren(visitor, calcTreeElement()); + } + + @Override + protected Object clone() { + CompositeElement treeElement = calcTreeElement(); + CompositeElement treeElementClone = + (CompositeElement)(treeElement.getTreeParent() != null ? treeElement.copyElement() : (ASTNode)treeElement.clone()); + /* + if (treeElementClone.getPsiElement() != null) { + return treeElementClone.getPsiElement(); + } + */ + return cloneImpl(treeElementClone); + } + + protected StubBasedPsiElementBase cloneImpl(@Nonnull CompositeElement treeElementClone) { + StubBasedPsiElementBase clone = (StubBasedPsiElementBase)super.clone(); + clone.setNode(treeElementClone); + treeElementClone.setPsi(clone); + return clone; + } + + @Override + public void subtreeChanged() { + final CompositeElement compositeElement = calcTreeElement(); + if (compositeElement != null) { + compositeElement.clearCaches(); + } + super.subtreeChanged(); + } + + @RequiredReadAction + @Override + @Nonnull + public PsiElement[] getChildren() { + PsiElement psiChild = getFirstChild(); + if (psiChild == null) { + return PsiElement.EMPTY_ARRAY; + } + + int count = 0; + while (psiChild != null) { + count++; + psiChild = psiChild.getNextSibling(); + } + + PsiElement[] answer = new PsiElement[count]; + count = 0; + psiChild = getFirstChild(); + while (psiChild != null) { + answer[count++] = psiChild; + psiChild = psiChild.getNextSibling(); + } + + return answer; + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java index 6d173e2b6f..5f79e24802 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java @@ -31,331 +31,346 @@ import static com.intellij.java.language.psi.PsiModifier.*; public class PsiModifierListImpl extends JavaStubPsiElement implements PsiModifierList { - private static final Map NAME_TO_KEYWORD_TYPE_MAP; - private static final Map KEYWORD_TYPE_TO_NAME_MAP; - - static { - NAME_TO_KEYWORD_TYPE_MAP = new HashMap<>(); - NAME_TO_KEYWORD_TYPE_MAP.put(PUBLIC, JavaTokenType.PUBLIC_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(PROTECTED, JavaTokenType.PROTECTED_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(PRIVATE, JavaTokenType.PRIVATE_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(STATIC, JavaTokenType.STATIC_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(ABSTRACT, JavaTokenType.ABSTRACT_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(FINAL, JavaTokenType.FINAL_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(NATIVE, JavaTokenType.NATIVE_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(SYNCHRONIZED, JavaTokenType.SYNCHRONIZED_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(STRICTFP, JavaTokenType.STRICTFP_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(TRANSIENT, JavaTokenType.TRANSIENT_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(VOLATILE, JavaTokenType.VOLATILE_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(DEFAULT, JavaTokenType.DEFAULT_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(OPEN, JavaTokenType.OPEN_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(TRANSITIVE, JavaTokenType.TRANSITIVE_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(SEALED, JavaTokenType.SEALED_KEYWORD); - NAME_TO_KEYWORD_TYPE_MAP.put(NON_SEALED, JavaTokenType.NON_SEALED_KEYWORD); - - KEYWORD_TYPE_TO_NAME_MAP = new HashMap<>(); - for (String name : NAME_TO_KEYWORD_TYPE_MAP.keySet()) { - KEYWORD_TYPE_TO_NAME_MAP.put(NAME_TO_KEYWORD_TYPE_MAP.get(name), name); + private static final Map NAME_TO_KEYWORD_TYPE_MAP; + private static final Map KEYWORD_TYPE_TO_NAME_MAP; + + static { + NAME_TO_KEYWORD_TYPE_MAP = new HashMap<>(); + NAME_TO_KEYWORD_TYPE_MAP.put(PUBLIC, JavaTokenType.PUBLIC_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(PROTECTED, JavaTokenType.PROTECTED_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(PRIVATE, JavaTokenType.PRIVATE_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(STATIC, JavaTokenType.STATIC_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(ABSTRACT, JavaTokenType.ABSTRACT_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(FINAL, JavaTokenType.FINAL_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(NATIVE, JavaTokenType.NATIVE_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(SYNCHRONIZED, JavaTokenType.SYNCHRONIZED_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(STRICTFP, JavaTokenType.STRICTFP_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(TRANSIENT, JavaTokenType.TRANSIENT_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(VOLATILE, JavaTokenType.VOLATILE_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(DEFAULT, JavaTokenType.DEFAULT_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(OPEN, JavaTokenType.OPEN_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(TRANSITIVE, JavaTokenType.TRANSITIVE_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(SEALED, JavaTokenType.SEALED_KEYWORD); + NAME_TO_KEYWORD_TYPE_MAP.put(NON_SEALED, JavaTokenType.NON_SEALED_KEYWORD); + + KEYWORD_TYPE_TO_NAME_MAP = new HashMap<>(); + for (String name : NAME_TO_KEYWORD_TYPE_MAP.keySet()) { + KEYWORD_TYPE_TO_NAME_MAP.put(NAME_TO_KEYWORD_TYPE_MAP.get(name), name); + } } - } - - private volatile ModifierCache myModifierCache; - public PsiModifierListImpl(final PsiModifierListStub stub) { - super(stub, JavaStubElementTypes.MODIFIER_LIST); - } + private volatile ModifierCache myModifierCache; - public PsiModifierListImpl(final ASTNode node) { - super(node); - } + public PsiModifierListImpl(final PsiModifierListStub stub) { + super(stub, JavaStubElementTypes.MODIFIER_LIST); + } - @Override - public boolean hasModifierProperty(@Nonnull String name) { - ModifierCache modifierCache = myModifierCache; - if (modifierCache == null || !modifierCache.isUpToDate()) { - myModifierCache = modifierCache = calcModifiers(); + public PsiModifierListImpl(final ASTNode node) { + super(node); } - return modifierCache.modifiers.contains(name); - } - - private ModifierCache calcModifiers() { - Set modifiers = calcExplicitModifiers(); - modifiers.addAll(calcImplicitModifiers(modifiers)); - if (!modifiers.contains(PUBLIC) && !modifiers.contains(PROTECTED) && !modifiers.contains(PRIVATE)) { - modifiers.add(PACKAGE_LOCAL); + + @Override + public boolean hasModifierProperty(@Nonnull String name) { + ModifierCache modifierCache = myModifierCache; + if (modifierCache == null || !modifierCache.isUpToDate()) { + myModifierCache = modifierCache = calcModifiers(); + } + return modifierCache.modifiers.contains(name); } - PsiFile file = getContainingFile(); - return new ModifierCache(file, PsiAugmentProvider.transformModifierProperties(this, file.getProject(), modifiers)); - } - - private Set calcExplicitModifiers() { - Set explicitModifiers = new HashSet<>(); - PsiModifierListStub stub = getGreenStub(); - if (stub != null) { - int mask = stub.getModifiersMask(); - for (int i = 0; i < 31; i++) { - int flag = 1 << i; - if (BitUtil.isSet(mask, flag)) { - ContainerUtil.addIfNotNull(explicitModifiers, ModifierFlags.MODIFIER_FLAG_TO_NAME_MAP.get(flag)); + + private ModifierCache calcModifiers() { + Set modifiers = calcExplicitModifiers(); + modifiers.addAll(calcImplicitModifiers(modifiers)); + if (!modifiers.contains(PUBLIC) && !modifiers.contains(PROTECTED) && !modifiers.contains(PRIVATE)) { + modifiers.add(PACKAGE_LOCAL); } - } + PsiFile file = getContainingFile(); + return new ModifierCache(file, PsiAugmentProvider.transformModifierProperties(this, file.getProject(), modifiers)); } - else { - for (ASTNode child : getNode().getChildren(null)) { - ContainerUtil.addIfNotNull(explicitModifiers, KEYWORD_TYPE_TO_NAME_MAP.get(child.getElementType())); - } + + private Set calcExplicitModifiers() { + Set explicitModifiers = new HashSet<>(); + PsiModifierListStub stub = getGreenStub(); + if (stub != null) { + int mask = stub.getModifiersMask(); + for (int i = 0; i < 31; i++) { + int flag = 1 << i; + if (BitUtil.isSet(mask, flag)) { + ContainerUtil.addIfNotNull(explicitModifiers, ModifierFlags.MODIFIER_FLAG_TO_NAME_MAP.get(flag)); + } + } + } + else { + for (ASTNode child : getNode().getChildren(null)) { + ContainerUtil.addIfNotNull(explicitModifiers, KEYWORD_TYPE_TO_NAME_MAP.get(child.getElementType())); + } + } + + return explicitModifiers; } - return explicitModifiers; - } - - private Set calcImplicitModifiers(Set explicitModifiers) { - Set implicitModifiers = new HashSet<>(); - PsiElement parent = getParent(); - if (parent instanceof PsiClass) { - PsiElement grandParent = parent.getContext(); - if (grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { - Collections.addAll(implicitModifiers, PUBLIC, STATIC); - } - if (((PsiClass)parent).isInterface()) { - implicitModifiers.add(ABSTRACT); - - // nested or local interface is implicitly static - if (!(grandParent instanceof PsiFile)) { - implicitModifiers.add(STATIC); + private Set calcImplicitModifiers(Set explicitModifiers) { + Set implicitModifiers = new HashSet<>(); + PsiElement parent = getParent(); + if (parent instanceof PsiClass) { + PsiElement grandParent = parent.getContext(); + if (grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + Collections.addAll(implicitModifiers, PUBLIC, STATIC); + } + if (((PsiClass)parent).isInterface()) { + implicitModifiers.add(ABSTRACT); + + // nested or local interface is implicitly static + if (!(grandParent instanceof PsiFile)) { + implicitModifiers.add(STATIC); + } + } + if (((PsiClass)parent).isRecord()) { + if (!(grandParent instanceof PsiFile)) { + implicitModifiers.add(STATIC); + } + implicitModifiers.add(FINAL); + } + if (((PsiClass)parent).isEnum()) { + if (!(grandParent instanceof PsiFile)) { + implicitModifiers.add(STATIC); + } + List fields = parent instanceof PsiExtensibleClass ? ((PsiExtensibleClass)parent).getOwnFields() + : Arrays.asList(((PsiClass)parent).getFields()); + boolean hasSubClass = ContainerUtil.find( + fields, + field -> field instanceof PsiEnumConstant && ((PsiEnumConstant)field).getInitializingClass() != null + ) != null; + if (hasSubClass) { + implicitModifiers.add(SEALED); + } + else { + implicitModifiers.add(FINAL); + } + + List methods = parent instanceof PsiExtensibleClass ? ((PsiExtensibleClass)parent).getOwnMethods() + : Arrays.asList(((PsiClass)parent).getMethods()); + for (PsiMethod method : methods) { + if (method.hasModifierProperty(ABSTRACT)) { + implicitModifiers.add(ABSTRACT); + break; + } + } + } } - } - if (((PsiClass)parent).isRecord()) { - if (!(grandParent instanceof PsiFile)) { - implicitModifiers.add(STATIC); + else if (parent instanceof PsiMethod) { + PsiClass aClass = ((PsiMethod)parent).getContainingClass(); + if (aClass != null && aClass.isInterface()) { + if (!explicitModifiers.contains(PRIVATE)) { + implicitModifiers.add(PUBLIC); + if (!explicitModifiers.contains(DEFAULT) && !explicitModifiers.contains(STATIC)) { + implicitModifiers.add(ABSTRACT); + } + } + } + else if (aClass != null && aClass.isEnum() && ((PsiMethod)parent).isConstructor()) { + implicitModifiers.add(PRIVATE); + } } - implicitModifiers.add(FINAL); - } - if (((PsiClass)parent).isEnum()) { - if (!(grandParent instanceof PsiFile)) { - implicitModifiers.add(STATIC); + else if (parent instanceof PsiRecordComponent) { + implicitModifiers.add(FINAL); } - List fields = parent instanceof PsiExtensibleClass ? ((PsiExtensibleClass)parent).getOwnFields() - : Arrays.asList(((PsiClass)parent).getFields()); - boolean hasSubClass = ContainerUtil.find(fields, - field -> field instanceof PsiEnumConstant && ((PsiEnumConstant)field).getInitializingClass() != null) != null; - if (hasSubClass) { - implicitModifiers.add(SEALED); + else if (parent instanceof PsiField) { + if (parent instanceof PsiEnumConstant) { + Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL); + } + else { + PsiClass aClass = ((PsiField)parent).getContainingClass(); + if (aClass != null && aClass.isInterface()) { + Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL); + } + } } - else { - implicitModifiers.add(FINAL); + else if (parent instanceof PsiParameter && + parent.getParent() instanceof PsiCatchSection && + ((PsiParameter)parent).getType() instanceof PsiDisjunctionType) { + Collections.addAll(implicitModifiers, FINAL); } - - List methods = parent instanceof PsiExtensibleClass ? ((PsiExtensibleClass)parent).getOwnMethods() - : Arrays.asList(((PsiClass)parent).getMethods()); - for (PsiMethod method : methods) { - if (method.hasModifierProperty(ABSTRACT)) { - implicitModifiers.add(ABSTRACT); - break; - } + else if (parent instanceof PsiResourceVariable) { + Collections.addAll(implicitModifiers, FINAL); } - } + return implicitModifiers; } - else if (parent instanceof PsiMethod) { - PsiClass aClass = ((PsiMethod)parent).getContainingClass(); - if (aClass != null && aClass.isInterface()) { - if (!explicitModifiers.contains(PRIVATE)) { - implicitModifiers.add(PUBLIC); - if (!explicitModifiers.contains(DEFAULT) && !explicitModifiers.contains(STATIC)) { - implicitModifiers.add(ABSTRACT); - } + + @Override + public boolean hasExplicitModifier(@Nonnull String name) { + PsiModifierListStub stub = getGreenStub(); + if (stub != null) { + return BitUtil.isSet(stub.getModifiersMask(), ModifierFlags.NAME_TO_MODIFIER_FLAG_MAP.getInt(name)); } - } - else if (aClass != null && aClass.isEnum() && ((PsiMethod)parent).isConstructor()) { - implicitModifiers.add(PRIVATE); - } - } - else if (parent instanceof PsiRecordComponent) { - implicitModifiers.add(FINAL); + + final CompositeElement tree = (CompositeElement)getNode(); + final IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name); + return type != null && tree.findChildByType(type) != null; } - else if (parent instanceof PsiField) { - if (parent instanceof PsiEnumConstant) { - Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL); - } - else { - PsiClass aClass = ((PsiField)parent).getContainingClass(); - if (aClass != null && aClass.isInterface()) { - Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL); + + @Override + public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { + checkSetModifierProperty(name, value); + + PsiElement parent = getParent(); + PsiElement grandParent = parent != null ? parent.getParent() : null; + IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name); + CompositeElement treeElement = (CompositeElement)getNode(); + + // There is a possible case that parameters list occupies more than one line and its elements are aligned. Modifiers list change + // changes horizontal position of parameters list start, hence, we need to reformat them in order to preserve alignment. + if (parent instanceof PsiMethod) { + PsiMethod method = (PsiMethod)parent; + ASTNode node = method.getParameterList().getNode(); + if (node != null) { // could be a compact constructor parameter list + CodeEditUtil.markToReformat(node, true); + } + } + + if (value) { + if (type == JavaTokenType.PUBLIC_KEYWORD || + type == JavaTokenType.PRIVATE_KEYWORD || + type == JavaTokenType.PROTECTED_KEYWORD || + type == null /* package-private */) { + if (type != JavaTokenType.PUBLIC_KEYWORD) { + setModifierProperty(PUBLIC, false); + } + if (type != JavaTokenType.PRIVATE_KEYWORD) { + setModifierProperty(PRIVATE, false); + } + if (type != JavaTokenType.PROTECTED_KEYWORD) { + setModifierProperty(PROTECTED, false); + } + if (type == null) { + return; + } + } + + if (type == JavaTokenType.SEALED_KEYWORD || type == JavaTokenType.FINAL_KEYWORD || type == JavaTokenType.NON_SEALED_KEYWORD) { + if (type != JavaTokenType.SEALED_KEYWORD) { + setModifierProperty(SEALED, false); + } + if (type != JavaTokenType.NON_SEALED_KEYWORD) { + setModifierProperty(NON_SEALED, false); + } + if (type != JavaTokenType.FINAL_KEYWORD) { + setModifierProperty(FINAL, false); + } + } + + if (parent instanceof PsiField && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.STATIC_KEYWORD || type == JavaTokenType.FINAL_KEYWORD) { + return; + } + } + else if (parent instanceof PsiMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) { + return; + } + } + else if (parent instanceof PsiClass && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + if (type == JavaTokenType.PUBLIC_KEYWORD) { + return; + } + } + else if (parent instanceof PsiAnnotationMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isAnnotationType()) { + if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) { + return; + } + } + + if (treeElement.findChildByType(type) == null) { + TreeElement keyword = Factory.createSingleLeafElement(type, name, null, getManager()); + treeElement.addInternal(keyword, keyword, null, null); + } + } + else { + if (type == null /* package-private */) { + throw new IncorrectOperationException("Cannot reset package-private modifier."); //? + } + + ASTNode child = treeElement.findChildByType(type); + if (child != null) { + SourceTreeToPsiMap.treeToPsiNotNull(child).delete(); + } } - } } - else if (parent instanceof PsiParameter && - parent.getParent() instanceof PsiCatchSection && - ((PsiParameter)parent).getType() instanceof PsiDisjunctionType) { - Collections.addAll(implicitModifiers, FINAL); + + @Override + public void checkSetModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { + CheckUtil.checkWritable(this); } - else if (parent instanceof PsiResourceVariable) { - Collections.addAll(implicitModifiers, FINAL); + + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + PsiAnnotation[] own = getStubOrPsiChildren(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY); + List ext = PsiAugmentProvider.collectAugments(this, PsiAnnotation.class, null); + return ArrayUtil.mergeArrayAndCollection(own, ext, PsiAnnotation.ARRAY_FACTORY); } - return implicitModifiers; - } - - @Override - public boolean hasExplicitModifier(@Nonnull String name) { - PsiModifierListStub stub = getGreenStub(); - if (stub != null) { - return BitUtil.isSet(stub.getModifiersMask(), ModifierFlags.NAME_TO_MODIFIER_FLAG_MAP.getInt(name)); + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + PsiAnnotation.TargetType[] targets = AnnotationTargetUtil.getTargetsForLocation(this); + List filtered = ContainerUtil.findAll(getAnnotations(), annotation -> { + PsiAnnotation.TargetType target = AnnotationTargetUtil.findAnnotationTarget(annotation, targets); + return target != null && target != PsiAnnotation.TargetType.UNKNOWN; + }); + + return filtered.toArray(PsiAnnotation.EMPTY_ARRAY); } - final CompositeElement tree = (CompositeElement)getNode(); - final IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name); - return type != null && tree.findChildByType(type) != null; - } - - @Override - public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { - checkSetModifierProperty(name, value); - - PsiElement parent = getParent(); - PsiElement grandParent = parent != null ? parent.getParent() : null; - IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name); - CompositeElement treeElement = (CompositeElement)getNode(); - - // There is a possible case that parameters list occupies more than one line and its elements are aligned. Modifiers list change - // changes horizontal position of parameters list start, hence, we need to reformat them in order to preserve alignment. - if (parent instanceof PsiMethod) { - PsiMethod method = (PsiMethod)parent; - ASTNode node = method.getParameterList().getNode(); - if (node != null) { // could be a compact constructor parameter list - CodeEditUtil.markToReformat(node, true); - } + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + return PsiImplUtil.findAnnotation(this, qualifiedName); } - if (value) { - if (type == JavaTokenType.PUBLIC_KEYWORD || - type == JavaTokenType.PRIVATE_KEYWORD || - type == JavaTokenType.PROTECTED_KEYWORD || - type == null /* package-private */) { - if (type != JavaTokenType.PUBLIC_KEYWORD) { - setModifierProperty(PUBLIC, false); - } - if (type != JavaTokenType.PRIVATE_KEYWORD) { - setModifierProperty(PRIVATE, false); - } - if (type != JavaTokenType.PROTECTED_KEYWORD) { - setModifierProperty(PROTECTED, false); - } - if (type == null) return; - } + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { + return (PsiAnnotation)addAfter( + JavaPsiFacade.getElementFactory(getProject()).createAnnotationFromText("@" + qualifiedName, this), + null + ); + } - if (type == JavaTokenType.SEALED_KEYWORD || type == JavaTokenType.FINAL_KEYWORD || type == JavaTokenType.NON_SEALED_KEYWORD) { - if (type != JavaTokenType.SEALED_KEYWORD) { - setModifierProperty(SEALED, false); - } - if (type != JavaTokenType.NON_SEALED_KEYWORD) { - setModifierProperty(NON_SEALED, false); + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitModifierList(this); } - if (type != JavaTokenType.FINAL_KEYWORD) { - setModifierProperty(FINAL, false); + else { + visitor.visitElement(this); } - } - - if (parent instanceof PsiField && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { - if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.STATIC_KEYWORD || type == JavaTokenType.FINAL_KEYWORD) return; - } - else if (parent instanceof PsiMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { - if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) return; - } - else if (parent instanceof PsiClass && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { - if (type == JavaTokenType.PUBLIC_KEYWORD) return; - } - else if (parent instanceof PsiAnnotationMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isAnnotationType()) { - if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) return; - } - - if (treeElement.findChildByType(type) == null) { - TreeElement keyword = Factory.createSingleLeafElement(type, name, null, getManager()); - treeElement.addInternal(keyword, keyword, null, null); - } - } - else { - if (type == null /* package-private */) { - throw new IncorrectOperationException("Cannot reset package-private modifier."); //? - } - - ASTNode child = treeElement.findChildByType(type); - if (child != null) { - SourceTreeToPsiMap.treeToPsiNotNull(child).delete(); - } - } - } - - @Override - public void checkSetModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { - CheckUtil.checkWritable(this); - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - PsiAnnotation[] own = getStubOrPsiChildren(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY); - List ext = PsiAugmentProvider.collectAugments(this, PsiAnnotation.class, null); - return ArrayUtil.mergeArrayAndCollection(own, ext, PsiAnnotation.ARRAY_FACTORY); - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - PsiAnnotation.TargetType[] targets = AnnotationTargetUtil.getTargetsForLocation(this); - List filtered = ContainerUtil.findAll(getAnnotations(), annotation -> { - PsiAnnotation.TargetType target = AnnotationTargetUtil.findAnnotationTarget(annotation, targets); - return target != null && target != PsiAnnotation.TargetType.UNKNOWN; - }); - - return filtered.toArray(PsiAnnotation.EMPTY_ARRAY); - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - return PsiImplUtil.findAnnotation(this, qualifiedName); - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { - return (PsiAnnotation)addAfter(JavaPsiFacade.getElementFactory(getProject()).createAnnotationFromText("@" + qualifiedName, this), null); - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitModifierList(this); - } - else { - visitor.visitElement(this); - } - } - - @Override - public String toString() { - return "PsiModifierList:" + getText(); - } - - private static class ModifierCache { - static final Interner> ourInterner = Interner.createWeakInterner(); - final PsiFile file; - final List modifiers; - final long modCount; - - ModifierCache(@Nonnull PsiFile file, @Nonnull Set modifiers) { - this.file = file; - List modifierList = new ArrayList<>(modifiers); - Collections.sort(modifierList); - this.modifiers = ourInterner.intern(modifierList); - this.modCount = getModCount(); } - private long getModCount() { - return file.getManager().getModificationTracker().getModificationCount() + file.getModificationStamp(); + @Override + public String toString() { + return "PsiModifierList:" + getText(); } - boolean isUpToDate() { - return getModCount() == modCount; + private static class ModifierCache { + static final Interner> ourInterner = Interner.createWeakInterner(); + final PsiFile file; + final List modifiers; + final long modCount; + + ModifierCache(@Nonnull PsiFile file, @Nonnull Set modifiers) { + this.file = file; + List modifierList = new ArrayList<>(modifiers); + Collections.sort(modifierList); + this.modifiers = ourInterner.intern(modifierList); + this.modCount = getModCount(); + } + + private long getModCount() { + return file.getManager().getModificationTracker().getModificationCount() + file.getModificationStamp(); + } + + boolean isUpToDate() { + return getModCount() == modCount; + } } - } } \ No newline at end of file diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java index 87899e2336..945e3f2848 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java @@ -53,415 +53,442 @@ import java.util.List; public class PsiTypeElementImpl extends CompositePsiElement implements PsiTypeElement { - @SuppressWarnings("UnusedDeclaration") - public PsiTypeElementImpl() { - this(JavaElementType.TYPE); - } - - PsiTypeElementImpl(@Nonnull IElementType type) { - super(type); - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeElement(this); + @SuppressWarnings("UnusedDeclaration") + public PsiTypeElementImpl() { + this(JavaElementType.TYPE); } - else { - visitor.visitElement(this); - } - } - - @Override - @Nonnull - public PsiType getType() { - return LanguageCachedValueUtil.getCachedValue(this, - () -> CachedValueProvider.Result.create(calculateType(), - PsiModificationTracker.MODIFICATION_COUNT)); - } - - @Nonnull - private PsiType calculateType() { - PsiType inferredType = PsiAugmentProvider.getInferredType(this); - if (inferredType != null) { - return inferredType; - } - - PsiType type = null; - boolean ellipsis = false; - List annotations = new SmartList<>(); - List arrayComponentAnnotations = new SmartList<>(); - PsiElement parent = getParent(); - PsiElement firstChild = getFirstChild(); - if (firstChild == null && parent instanceof PsiUnnamedPattern) { - type = JavaPsiPatternUtil.getDeconstructedImplicitPatternType((PsiPattern)parent); + PsiTypeElementImpl(@Nonnull IElementType type) { + super(type); } - for (PsiElement child = firstChild; child != null; child = child.getNextSibling()) { - if (child instanceof PsiComment || child instanceof PsiWhiteSpace) continue; - - if (child instanceof PsiAnnotation) { - annotations.add((PsiAnnotation)child); - } - else if (child instanceof PsiTypeElement) { - assert type == null : this; - if (child instanceof PsiDiamondTypeElementImpl) { - type = new PsiDiamondTypeImpl(getManager(), this); - break; + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeElement(this); } else { - type = ((PsiTypeElement)child).getType(); + visitor.visitElement(this); } - } - else if (PsiUtil.isJavaToken(child, ElementType.PRIMITIVE_TYPE_BIT_SET)) { - assert type == null : this; - String text = child.getText(); - type = - annotations.isEmpty() ? PsiJavaParserFacadeImpl.getPrimitiveType(text) : new PsiPrimitiveType(text, createProvider(annotations)); - } - else if (PsiUtil.isJavaToken(child, JavaTokenType.VAR_KEYWORD)) { - assert type == null : this; - type = inferVarType(parent); - } - else if (child instanceof PsiJavaCodeReferenceElement) { - assert type == null : this; - type = new PsiClassReferenceType(getReferenceComputable((PsiJavaCodeReferenceElement)child), null, createProvider(annotations)); - } - else if (PsiUtil.isJavaToken(child, JavaTokenType.LBRACKET)) { - assert type != null : this; - arrayComponentAnnotations.add(createProvider(annotations)); - annotations = new SmartList<>(); - } - else if (PsiUtil.isJavaToken(child, JavaTokenType.ELLIPSIS)) { - assert type != null : this; - arrayComponentAnnotations.add(createProvider(annotations)); - annotations = new SmartList<>(); - ellipsis = true; - } - - if (PsiUtil.isJavaToken(child, JavaTokenType.QUEST)) { - assert type == null : this; - PsiElement boundKind = PsiTreeUtil.skipWhitespacesAndCommentsForward(child); - PsiElement boundType = PsiTreeUtil.skipWhitespacesAndCommentsForward(boundKind); - if (PsiUtil.isJavaToken(boundKind, JavaTokenType.EXTENDS_KEYWORD) && boundType instanceof PsiTypeElement) { - type = PsiWildcardType.createExtends(getManager(), ((PsiTypeElement)boundType).getType()); + } + + @Override + @Nonnull + public PsiType getType() { + return LanguageCachedValueUtil.getCachedValue( + this, + () -> CachedValueProvider.Result.create( + calculateType(), + PsiModificationTracker.MODIFICATION_COUNT + ) + ); + } + + @Nonnull + private PsiType calculateType() { + PsiType inferredType = PsiAugmentProvider.getInferredType(this); + if (inferredType != null) { + return inferredType; } - else if (PsiUtil.isJavaToken(boundKind, JavaTokenType.SUPER_KEYWORD) && boundType instanceof PsiTypeElement) { - type = PsiWildcardType.createSuper(getManager(), ((PsiTypeElement)boundType).getType()); + + PsiType type = null; + boolean ellipsis = false; + List annotations = new SmartList<>(); + List arrayComponentAnnotations = new SmartList<>(); + + PsiElement parent = getParent(); + PsiElement firstChild = getFirstChild(); + if (firstChild == null && parent instanceof PsiUnnamedPattern) { + type = JavaPsiPatternUtil.getDeconstructedImplicitPatternType((PsiPattern)parent); } - else { - type = PsiWildcardType.createUnbounded(getManager()); + for (PsiElement child = firstChild; child != null; child = child.getNextSibling()) { + if (child instanceof PsiComment || child instanceof PsiWhiteSpace) { + continue; + } + + if (child instanceof PsiAnnotation) { + annotations.add((PsiAnnotation)child); + } + else if (child instanceof PsiTypeElement) { + assert type == null : this; + if (child instanceof PsiDiamondTypeElementImpl) { + type = new PsiDiamondTypeImpl(getManager(), this); + break; + } + else { + type = ((PsiTypeElement)child).getType(); + } + } + else if (PsiUtil.isJavaToken(child, ElementType.PRIMITIVE_TYPE_BIT_SET)) { + assert type == null : this; + String text = child.getText(); + type = + annotations.isEmpty() ? PsiJavaParserFacadeImpl.getPrimitiveType(text) : new PsiPrimitiveType( + text, + createProvider(annotations) + ); + } + else if (PsiUtil.isJavaToken(child, JavaTokenType.VAR_KEYWORD)) { + assert type == null : this; + type = inferVarType(parent); + } + else if (child instanceof PsiJavaCodeReferenceElement) { + assert type == null : this; + type = new PsiClassReferenceType( + getReferenceComputable((PsiJavaCodeReferenceElement)child), + null, + createProvider(annotations) + ); + } + else if (PsiUtil.isJavaToken(child, JavaTokenType.LBRACKET)) { + assert type != null : this; + arrayComponentAnnotations.add(createProvider(annotations)); + annotations = new SmartList<>(); + } + else if (PsiUtil.isJavaToken(child, JavaTokenType.ELLIPSIS)) { + assert type != null : this; + arrayComponentAnnotations.add(createProvider(annotations)); + annotations = new SmartList<>(); + ellipsis = true; + } + + if (PsiUtil.isJavaToken(child, JavaTokenType.QUEST)) { + assert type == null : this; + PsiElement boundKind = PsiTreeUtil.skipWhitespacesAndCommentsForward(child); + PsiElement boundType = PsiTreeUtil.skipWhitespacesAndCommentsForward(boundKind); + if (PsiUtil.isJavaToken(boundKind, JavaTokenType.EXTENDS_KEYWORD) && boundType instanceof PsiTypeElement) { + type = PsiWildcardType.createExtends(getManager(), ((PsiTypeElement)boundType).getType()); + } + else if (PsiUtil.isJavaToken(boundKind, JavaTokenType.SUPER_KEYWORD) && boundType instanceof PsiTypeElement) { + type = PsiWildcardType.createSuper(getManager(), ((PsiTypeElement)boundType).getType()); + } + else { + type = PsiWildcardType.createUnbounded(getManager()); + } + type = type.annotate(createProvider(annotations)); + break; + } + else { + if (child instanceof ASTNode) { + ((ASTNode)child).getElementType(); + } + } + + if (PsiUtil.isJavaToken(child, JavaTokenType.AND)) { + List types = collectTypes(); + assert !types.isEmpty() : this; + type = PsiIntersectionType.createIntersection(false, types.toArray(PsiType.createArray(types.size()))); + break; + } + + if (PsiUtil.isJavaToken(child, JavaTokenType.OR)) { + List types = collectTypes(); + assert !types.isEmpty() : this; + type = PsiDisjunctionType.createDisjunction(types, getManager()); + break; + } } - type = type.annotate(createProvider(annotations)); - break; - } - else { - if (child instanceof ASTNode) { - ((ASTNode)child).getElementType(); + + if (type == null) { + return PsiTypes.nullType(); } - } - - if (PsiUtil.isJavaToken(child, JavaTokenType.AND)) { - List types = collectTypes(); - assert !types.isEmpty() : this; - type = PsiIntersectionType.createIntersection(false, types.toArray(PsiType.createArray(types.size()))); - break; - } - - if (PsiUtil.isJavaToken(child, JavaTokenType.OR)) { - List types = collectTypes(); - assert !types.isEmpty() : this; - type = PsiDisjunctionType.createDisjunction(types, getManager()); - break; - } - } - if (type == null) return PsiTypes.nullType(); + if (!arrayComponentAnnotations.isEmpty()) { + type = createArray(type, arrayComponentAnnotations, ellipsis); + } + + if (parent instanceof PsiModifierListOwner) { + type = JavaSharedImplUtil.applyAnnotations(type, ((PsiModifierListOwner)parent).getModifierList()); + } - if (!arrayComponentAnnotations.isEmpty()) { - type = createArray(type, arrayComponentAnnotations, ellipsis); + return type; } - if (parent instanceof PsiModifierListOwner) { - type = JavaSharedImplUtil.applyAnnotations(type, ((PsiModifierListOwner)parent).getModifierList()); + private static PsiType createArray(PsiType elementType, List providers, boolean ellipsis) { + PsiType result = elementType; + for (int i = providers.size() - 1; i >= 0; i--) { + TypeAnnotationProvider provider = providers.get(i); + result = ellipsis && i == 0 ? new PsiEllipsisType(result, provider) : new PsiArrayType(result, provider); + } + providers.clear(); + return result; } - return type; - } + private PsiType inferVarType(PsiElement parent) { + if (parent instanceof PsiParameter) { + PsiParameter parameter = (PsiParameter)parent; + if (parameter instanceof PsiPatternVariable) { + return JavaPsiPatternUtil.getDeconstructedImplicitPatternVariableType((PsiPatternVariable)parameter); + } + PsiElement declarationScope = parameter.getDeclarationScope(); + if (declarationScope instanceof PsiForeachStatement) { + PsiExpression iteratedValue = ((PsiForeachStatement)declarationScope).getIteratedValue(); + if (iteratedValue != null) { + PsiType type = JavaGenericsUtil.getCollectionItemType(iteratedValue); + //Upward projection is applied to the type of the initializer when determining the type of the + //variable + return type != null ? JavaVarTypeUtil.getUpwardProjection(type) : null; + } + return null; + } - private static PsiType createArray(PsiType elementType, List providers, boolean ellipsis) { - PsiType result = elementType; - for (int i = providers.size() - 1; i >= 0; i--) { - TypeAnnotationProvider provider = providers.get(i); - result = ellipsis && i == 0 ? new PsiEllipsisType(result, provider) : new PsiArrayType(result, provider); - } - providers.clear(); - return result; - } - - private PsiType inferVarType(PsiElement parent) { - if (parent instanceof PsiParameter) { - PsiParameter parameter = (PsiParameter)parent; - if (parameter instanceof PsiPatternVariable) { - return JavaPsiPatternUtil.getDeconstructedImplicitPatternVariableType((PsiPatternVariable)parameter); - } - PsiElement declarationScope = parameter.getDeclarationScope(); - if (declarationScope instanceof PsiForeachStatement) { - PsiExpression iteratedValue = ((PsiForeachStatement)declarationScope).getIteratedValue(); - if (iteratedValue != null) { - PsiType type = JavaGenericsUtil.getCollectionItemType(iteratedValue); - //Upward projection is applied to the type of the initializer when determining the type of the - //variable - return type != null ? JavaVarTypeUtil.getUpwardProjection(type) : null; + if (declarationScope instanceof PsiLambdaExpression) { + return parameter.getType(); + } + } + else { + for (PsiElement e = this; e != null; e = e.getNextSibling()) { + if (e instanceof PsiExpression) { + if (!(e instanceof PsiArrayInitializerExpression)) { + PsiExpression expression = (PsiExpression)e; + RecursionGuard.StackStamp stamp = RecursionManager.markStack(); + PsiType type = RecursionManager.doPreventingRecursion(expression, true, () -> expression.getType()); + if (stamp.mayCacheNow()) { + return type == null ? null : JavaVarTypeUtil.getUpwardProjection(type); + } + return null; + } + return null; + } + } } return null; - } + } + - if (declarationScope instanceof PsiLambdaExpression) { - return parameter.getType(); - } + @Override + public boolean isInferredType() { + PsiElement firstChild = getFirstChild(); + return PsiUtil.isJavaToken(firstChild, JavaTokenType.VAR_KEYWORD) || PsiAugmentProvider.isInferredType(this); } - else { - for (PsiElement e = this; e != null; e = e.getNextSibling()) { - if (e instanceof PsiExpression) { - if (!(e instanceof PsiArrayInitializerExpression)) { - PsiExpression expression = (PsiExpression)e; - RecursionGuard.StackStamp stamp = RecursionManager.markStack(); - PsiType type = RecursionManager.doPreventingRecursion(expression, true, () -> expression.getType()); - if (stamp.mayCacheNow()) { - return type == null ? null : JavaVarTypeUtil.getUpwardProjection(type); + + @Nonnull + private static ClassReferencePointer getReferenceComputable(@Nonnull PsiJavaCodeReferenceElement ref) { + PsiTypeElement rootType = getRootTypeElement(ref); + if (rootType != null) { + PsiElement parent = rootType.getParent(); + if (parent instanceof PsiMethod || parent instanceof PsiVariable) { + int index = allReferencesInside(rootType).indexOf(ref::equals); + if (index < 0) { + throw new AssertionError(rootType.getClass()); + } + return computeFromTypeOwner(parent, index, new WeakReference<>(ref)); } - return null; - } - return null; } - } + return ClassReferencePointer.constant(ref); } - return null; - } - - - @Override - public boolean isInferredType() { - PsiElement firstChild = getFirstChild(); - return PsiUtil.isJavaToken(firstChild, JavaTokenType.VAR_KEYWORD) || PsiAugmentProvider.isInferredType(this); - } - - @Nonnull - private static ClassReferencePointer getReferenceComputable(@Nonnull PsiJavaCodeReferenceElement ref) { - PsiTypeElement rootType = getRootTypeElement(ref); - if (rootType != null) { - PsiElement parent = rootType.getParent(); - if (parent instanceof PsiMethod || parent instanceof PsiVariable) { - int index = allReferencesInside(rootType).indexOf(ref::equals); - if (index < 0) { - throw new AssertionError(rootType.getClass()); - } - return computeFromTypeOwner(parent, index, new WeakReference<>(ref)); - } + + @Nullable + private static PsiTypeElement getRootTypeElement(@Nonnull PsiJavaCodeReferenceElement ref) { + PsiElement root = SyntaxTraverser.psiApi() + .parents(ref.getParent()) + .takeWhile(it -> it instanceof PsiTypeElement || it instanceof PsiReferenceParameterList || it instanceof PsiJavaCodeReferenceElement) + .last(); + return ObjectUtil.tryCast(root, PsiTypeElement.class); } - return ClassReferencePointer.constant(ref); - } - - @Nullable - private static PsiTypeElement getRootTypeElement(@Nonnull PsiJavaCodeReferenceElement ref) { - PsiElement root = SyntaxTraverser.psiApi() - .parents(ref.getParent()) - .takeWhile(it -> it instanceof PsiTypeElement || it instanceof PsiReferenceParameterList || it instanceof PsiJavaCodeReferenceElement) - .last(); - return ObjectUtil.tryCast(root, PsiTypeElement.class); - } - - @Nonnull - private static ClassReferencePointer computeFromTypeOwner(PsiElement parent, int index, - @Nonnull WeakReference ref) { - return new ClassReferencePointer() { - volatile WeakReference myCache = ref; - - @Override - public - @Nullable - PsiJavaCodeReferenceElement retrieveReference() { - PsiJavaCodeReferenceElement result = myCache.get(); - if (result == null) { - PsiType type = calcTypeByParent(); - if (type instanceof PsiClassReferenceType) { - result = findReferenceByIndex((PsiClassReferenceType)type); - } - myCache = new WeakReference<>(result); + + @Nonnull + private static ClassReferencePointer computeFromTypeOwner( + PsiElement parent, + int index, + @Nonnull WeakReference ref + ) { + return new ClassReferencePointer() { + volatile WeakReference myCache = ref; + + @Override + public + @Nullable + PsiJavaCodeReferenceElement retrieveReference() { + PsiJavaCodeReferenceElement result = myCache.get(); + if (result == null) { + PsiType type = calcTypeByParent(); + if (type instanceof PsiClassReferenceType) { + result = findReferenceByIndex((PsiClassReferenceType)type); + } + myCache = new WeakReference<>(result); + } + return result; + } + + @Nullable + private PsiJavaCodeReferenceElement findReferenceByIndex(PsiClassReferenceType type) { + PsiTypeElement root = getRootTypeElement(type.getReference()); + return root == null ? null : allReferencesInside(root).get(index); + } + + @Nullable + private PsiType calcTypeByParent() { + if (!parent.isValid()) { + return null; + } + + PsiType type = parent instanceof PsiMethod ? ((PsiMethod)parent).getReturnType() : ((PsiVariable)parent).getType(); + if (type instanceof PsiArrayType) { //also, for c-style array, e.g. String args[] + return type.getDeepComponentType(); + } + return type; + } + + @Override + public + @Nonnull + PsiJavaCodeReferenceElement retrieveNonNullReference() { + PsiJavaCodeReferenceElement result = retrieveReference(); + if (result == null) { + PsiType type = calcTypeByParent(); + if (!(type instanceof PsiClassReferenceType)) { + PsiUtilCore.ensureValid(parent); + throw new IllegalStateException( + "No reference type for " + parent.getClass() + "; type: " + (type != null ? type.getClass() : "null") + ); + } + result = findReferenceByIndex((PsiClassReferenceType)type); + if (result == null) { + PsiUtilCore.ensureValid(parent); + throw new RuntimeExceptionWithAttachments( + "Can't retrieve reference by index " + index + " for " + parent.getClass() + "; type: " + type.getClass(), + AttachmentFactory.get().create("memberType.txt", type.getCanonicalText()) + ); + } + } + return result; + } + + @Override + public String toString() { + String msg = + "Type element reference of " + parent.getClass() + " #" + parent.getClass().getSimpleName() + ", index=" + index; + return parent.isValid() ? msg + " #" + parent.getLanguage() : msg + ", invalid"; + } + }; + } + + @Nonnull + private static JBIterable allReferencesInside(@Nonnull PsiTypeElement rootType) { + return SyntaxTraverser.psiTraverser(rootType).filter(PsiJavaCodeReferenceElement.class); + } + + @Nonnull + private static TypeAnnotationProvider createProvider(@Nonnull List annotations) { + return TypeAnnotationProvider.Static.create(ContainerUtil.copyAndClear(annotations, PsiAnnotation.ARRAY_FACTORY, true)); + } + + @Nonnull + private List collectTypes() { + List typeElements = PsiTreeUtil.getChildrenOfTypeAsList(this, PsiTypeElement.class); + return ContainerUtil.map(typeElements, typeElement -> typeElement.getType()); + } + + @Override + public PsiJavaCodeReferenceElement getInnermostComponentReferenceElement() { + TreeElement firstChildNode = getFirstChildNode(); + if (firstChildNode == null) { + return null; } - return result; - } - - @Nullable - private PsiJavaCodeReferenceElement findReferenceByIndex(PsiClassReferenceType type) { - PsiTypeElement root = getRootTypeElement(type.getReference()); - return root == null ? null : allReferencesInside(root).get(index); - } - - @Nullable - private PsiType calcTypeByParent() { - if (!parent.isValid()) { - return null; + if (firstChildNode.getElementType() == JavaElementType.TYPE) { + return SourceTreeToPsiMap.treeToPsiNotNull(firstChildNode).getInnermostComponentReferenceElement(); } + return getReferenceElement(); + } - PsiType type = parent instanceof PsiMethod ? ((PsiMethod)parent).getReturnType() : ((PsiVariable)parent).getType(); - if (type instanceof PsiArrayType) { //also, for c-style array, e.g. String args[] - return type.getDeepComponentType(); - } - return type; - } - - @Override - public - @Nonnull - PsiJavaCodeReferenceElement retrieveNonNullReference() { - PsiJavaCodeReferenceElement result = retrieveReference(); - if (result == null) { - PsiType type = calcTypeByParent(); - if (!(type instanceof PsiClassReferenceType)) { - PsiUtilCore.ensureValid(parent); - throw new IllegalStateException("No reference type for " + parent.getClass() + "; type: " + (type != null ? type.getClass() : "null")); - } - result = findReferenceByIndex((PsiClassReferenceType)type); - if (result == null) { - PsiUtilCore.ensureValid(parent); - throw new RuntimeExceptionWithAttachments("Can't retrieve reference by index " + index + " for " + parent.getClass() + "; type: " + type.getClass(), - AttachmentFactory.get().create("memberType.txt", type.getCanonicalText())); - } + @Nullable + private PsiJavaCodeReferenceElement getReferenceElement() { + ASTNode ref = findChildByType(JavaElementType.JAVA_CODE_REFERENCE); + if (ref == null) { + return null; } - return result; - } - - @Override - public String toString() { - String msg = "Type element reference of " + parent.getClass() + " #" + parent.getClass().getSimpleName() + ", index=" + index; - return parent.isValid() ? msg + " #" + parent.getLanguage() : msg + ", invalid"; - } - }; - } - - @Nonnull - private static JBIterable allReferencesInside(@Nonnull PsiTypeElement rootType) { - return SyntaxTraverser.psiTraverser(rootType).filter(PsiJavaCodeReferenceElement.class); - } - - @Nonnull - private static TypeAnnotationProvider createProvider(@Nonnull List annotations) { - return TypeAnnotationProvider.Static.create(ContainerUtil.copyAndClear(annotations, PsiAnnotation.ARRAY_FACTORY, true)); - } - - @Nonnull - private List collectTypes() { - List typeElements = PsiTreeUtil.getChildrenOfTypeAsList(this, PsiTypeElement.class); - return ContainerUtil.map(typeElements, typeElement -> typeElement.getType()); - } - - @Override - public PsiJavaCodeReferenceElement getInnermostComponentReferenceElement() { - TreeElement firstChildNode = getFirstChildNode(); - if (firstChildNode == null) { - return null; + return (PsiJavaCodeReferenceElement)SourceTreeToPsiMap.treeElementToPsi(ref); } - if (firstChildNode.getElementType() == JavaElementType.TYPE) { - return SourceTreeToPsiMap.treeToPsiNotNull(firstChildNode).getInnermostComponentReferenceElement(); + + @Override + public boolean processDeclarations( + @Nonnull PsiScopeProcessor processor, + @Nonnull ResolveState state, + PsiElement lastParent, + @Nonnull PsiElement place + ) { + processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this); + return true; } - return getReferenceElement(); - } - - @Nullable - private PsiJavaCodeReferenceElement getReferenceElement() { - ASTNode ref = findChildByType(JavaElementType.JAVA_CODE_REFERENCE); - if (ref == null) { - return null; + + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + PsiAnnotation[] annotations = PsiTreeUtil.getChildrenOfType(this, PsiAnnotation.class); + return annotations != null ? annotations : PsiAnnotation.EMPTY_ARRAY; } - return (PsiJavaCodeReferenceElement)SourceTreeToPsiMap.treeElementToPsi(ref); - } - - @Override - public boolean processDeclarations(@Nonnull PsiScopeProcessor processor, - @Nonnull ResolveState state, - PsiElement lastParent, - @Nonnull PsiElement place) { - processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this); - return true; - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - PsiAnnotation[] annotations = PsiTreeUtil.getChildrenOfType(this, PsiAnnotation.class); - return annotations != null ? annotations : PsiAnnotation.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getType().getAnnotations(); - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { - return PsiImplUtil.findAnnotation(this, qualifiedName); - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { - PsiAnnotation annotation = JavaPsiFacade.getElementFactory(getProject()).createAnnotationFromText('@' + qualifiedName, this); - PsiElement firstChild = getFirstChild(); - for (PsiElement child = getLastChild(); child != firstChild; child = child.getPrevSibling()) { - if (PsiUtil.isJavaToken(child, JavaTokenType.LBRACKET) || PsiUtil.isJavaToken(child, JavaTokenType.ELLIPSIS)) { - return (PsiAnnotation)addBefore(annotation, child); - } + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getType().getAnnotations(); } - if (firstChild instanceof PsiJavaCodeReferenceElement) { - PsiIdentifier identifier = PsiTreeUtil.getChildOfType(firstChild, PsiIdentifier.class); - if (identifier != null && identifier != firstChild.getFirstChild()) { - // qualified reference - return (PsiAnnotation)firstChild.addBefore(annotation, identifier); - } + + @Override + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { + return PsiImplUtil.findAnnotation(this, qualifiedName); } - PsiElement parent = getParent(); - while (parent instanceof PsiTypeElement && ((PsiTypeElement)parent).getType() instanceof PsiArrayType) { - parent = parent.getParent(); + + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { + PsiAnnotation annotation = JavaPsiFacade.getElementFactory(getProject()).createAnnotationFromText('@' + qualifiedName, this); + PsiElement firstChild = getFirstChild(); + for (PsiElement child = getLastChild(); child != firstChild; child = child.getPrevSibling()) { + if (PsiUtil.isJavaToken(child, JavaTokenType.LBRACKET) || PsiUtil.isJavaToken(child, JavaTokenType.ELLIPSIS)) { + return (PsiAnnotation)addBefore(annotation, child); + } + } + if (firstChild instanceof PsiJavaCodeReferenceElement) { + PsiIdentifier identifier = PsiTreeUtil.getChildOfType(firstChild, PsiIdentifier.class); + if (identifier != null && identifier != firstChild.getFirstChild()) { + // qualified reference + return (PsiAnnotation)firstChild.addBefore(annotation, identifier); + } + } + PsiElement parent = getParent(); + while (parent instanceof PsiTypeElement && ((PsiTypeElement)parent).getType() instanceof PsiArrayType) { + parent = parent.getParent(); + } + if (parent instanceof PsiModifierListOwner) { + PsiModifierList modifierList = ((PsiModifierListOwner)parent).getModifierList(); + if (modifierList != null) { + PsiTypeParameterList list = + parent instanceof PsiTypeParameterListOwner ? ((PsiTypeParameterListOwner)parent).getTypeParameterList() : null; + if (list == null || list.textMatches("")) { + return (PsiAnnotation)modifierList.add(annotation); + } + } + } + return (PsiAnnotation)addBefore(annotation, firstChild); } - if (parent instanceof PsiModifierListOwner) { - PsiModifierList modifierList = ((PsiModifierListOwner)parent).getModifierList(); - if (modifierList != null) { - PsiTypeParameterList list = - parent instanceof PsiTypeParameterListOwner ? ((PsiTypeParameterListOwner)parent).getTypeParameterList() : null; - if (list == null || list.textMatches("")) { - return (PsiAnnotation)modifierList.add(annotation); + + @Override + public PsiElement replace(@Nonnull PsiElement newElement) throws IncorrectOperationException { + // neighbouring type annotations are logical part of this type element and should be dropped + //if replacement is `var`, annotations should be left as they are not inferred from the right side of the assignment + if (!(newElement instanceof PsiTypeElement) || !((PsiTypeElement)newElement).isInferredType()) { + PsiImplUtil.markTypeAnnotations(this); } - } + PsiElement result = super.replace(newElement); + if (result instanceof PsiTypeElement) { + PsiImplUtil.deleteTypeAnnotations((PsiTypeElement)result); + } + return result; } - return (PsiAnnotation)addBefore(annotation, firstChild); - } - - @Override - public PsiElement replace(@Nonnull PsiElement newElement) throws IncorrectOperationException { - // neighbouring type annotations are logical part of this type element and should be dropped - //if replacement is `var`, annotations should be left as they are not inferred from the right side of the assignment - if (!(newElement instanceof PsiTypeElement) || !((PsiTypeElement)newElement).isInferredType()) { - PsiImplUtil.markTypeAnnotations(this); + + @Override + public boolean acceptsAnnotations() { + if (isInferredType()) { + return false; + } + PsiType type = getType(); + return !PsiTypes.voidType().equals(type) && !PsiTypes.nullType().equals(type); } - PsiElement result = super.replace(newElement); - if (result instanceof PsiTypeElement) { - PsiImplUtil.deleteTypeAnnotations((PsiTypeElement)result); + + @Override + public String toString() { + return "PsiTypeElement:" + getText(); } - return result; - } - - @Override - public boolean acceptsAnnotations() { - if (isInferredType()) return false; - PsiType type = getType(); - return !PsiTypes.voidType().equals(type) && !PsiTypes.nullType().equals(type); - } - - @Override - public String toString() { - return "PsiTypeElement:" + getText(); - } } \ No newline at end of file diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java index 2609bad87b..84ec65a0fb 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java @@ -44,6 +44,7 @@ import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.List; @@ -51,358 +52,372 @@ * @author dsl */ public class PsiTypeParameterImpl extends JavaStubPsiElement implements PsiTypeParameter, PsiMetaOwner { - private final LightEmptyImplementsList myLightEmptyImplementsList = new LightEmptyImplementsList(null) { - @Override - public PsiManager getManager() { - return PsiTypeParameterImpl.this.getManager(); - } - }; - - public PsiTypeParameterImpl(final PsiTypeParameterStub stub) { - super(stub, JavaStubElementTypes.TYPE_PARAMETER); - } - - public PsiTypeParameterImpl(final ASTNode node) { - super(node); - } - - @Override - public String getQualifiedName() { - return null; - } - - @Override - public boolean isInterface() { - return false; - } - - @Override - public boolean isAnnotationType() { - return false; - } - - @Override - public boolean isEnum() { - return false; - } - - @Override - @Nonnull - public PsiField[] getFields() { - return PsiField.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiMethod[] getMethods() { - return PsiMethod.EMPTY_ARRAY; - } - - @Override - public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) { - return PsiClassImplUtil.findMethodBySignature(this, patternMethod, checkBases); - } - - @Override - @Nonnull - public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) { - return PsiClassImplUtil.findMethodsBySignature(this, patternMethod, checkBases); - } - - @Override - public PsiField findFieldByName(String name, boolean checkBases) { - return PsiClassImplUtil.findFieldByName(this, name, checkBases); - } - - @Override - @Nonnull - public PsiMethod[] findMethodsByName(String name, boolean checkBases) { - return PsiClassImplUtil.findMethodsByName(this, name, checkBases); - } - - @Override - @Nonnull - public List> findMethodsAndTheirSubstitutorsByName(String name, boolean checkBases) { - return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); - } - - @Override - @Nonnull - public List> getAllMethodsAndTheirSubstitutors() { - return PsiClassImplUtil.getAllWithSubstitutorsByMap(this, PsiClassImplUtil.MemberType.METHOD); - } - - @Override - public PsiClass findInnerClassByName(String name, boolean checkBases) { - return PsiClassImplUtil.findInnerByName(this, name, checkBases); - } - - @Override - public PsiTypeParameterList getTypeParameterList() { - return null; - } - - @Override - public boolean hasTypeParameters() { - return false; - } - - // very special method! - @Override - public PsiElement getScope() { - return getParent().getParent(); - } - - @Override - public boolean isInheritorDeep(PsiClass baseClass, PsiClass classToByPass) { - return InheritanceImplUtil.isInheritorDeep(this, baseClass, classToByPass); - } - - @Override - public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { - return InheritanceImplUtil.isInheritor(this, baseClass, checkDeep); - } - - @Override - public PsiTypeParameterListOwner getOwner() { - final PsiElement parent = getParent(); - if (parent == null) throw new PsiInvalidElementAccessException(this); - final PsiElement parentParent = parent.getParent(); - if (!(parentParent instanceof PsiTypeParameterListOwner)) { - // Might be an error element; - return PsiTreeUtil.getParentOfType(this, PsiTypeParameterListOwner.class); - } - - return (PsiTypeParameterListOwner) parentParent; - } - - - @Override - public int getIndex() { - final PsiTypeParameterStub stub = getStub(); - if (stub != null) { - final PsiTypeParameterListStub parentStub = (PsiTypeParameterListStub) stub.getParentStub(); - return parentStub.getChildrenStubs().indexOf(stub); - } - - int ret = 0; - PsiElement element = getPrevSibling(); - while (element != null) { - if (element instanceof PsiTypeParameter) { - ret++; - } - element = element.getPrevSibling(); - } - return ret; - } - - @Override - @Nonnull - public PsiIdentifier getNameIdentifier() { - return PsiTreeUtil.getRequiredChildOfType(this, PsiIdentifier.class); - } - - @Override - public boolean processDeclarations(@Nonnull PsiScopeProcessor processor, - @Nonnull ResolveState state, - PsiElement lastParent, - @Nonnull PsiElement place) { - return PsiClassImplUtil.processDeclarationsInClass(this, processor, state, null, lastParent, place, PsiUtil.getLanguageLevel(place), false); - } - - @Override - public String getName() { - final PsiTypeParameterStub stub = getStub(); - if (stub != null) { - return stub.getName(); - } - - return getNameIdentifier().getText(); - } - - @Override - public PsiElement setName(@Nonnull String name) throws IncorrectOperationException { - PsiImplUtil.setName(getNameIdentifier(), name); - return this; - } - - @Override - @Nonnull - public PsiMethod[] getConstructors() { - return PsiMethod.EMPTY_ARRAY; - } - - @Override - public PsiDocComment getDocComment() { - return null; - } - - @Override - public boolean isDeprecated() { - return false; - } - - @Override - @Nonnull - public PsiReferenceList getExtendsList() { - return getRequiredStubOrPsiChild(JavaStubElementTypes.EXTENDS_BOUND_LIST); - } - - @Override - public PsiReferenceList getImplementsList() { - return myLightEmptyImplementsList; - } - - @Override - @Nonnull - public PsiClassType[] getExtendsListTypes() { - return PsiClassImplUtil.getExtendsListTypes(this); - } - - @Override - @Nonnull - public PsiClassType[] getImplementsListTypes() { - return PsiClassType.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiClass[] getInnerClasses() { - return PsiClass.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiField[] getAllFields() { - return PsiField.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiMethod[] getAllMethods() { - return PsiMethod.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiClass[] getAllInnerClasses() { - return PsiClass.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiClassInitializer[] getInitializers() { - return PsiClassInitializer.EMPTY_ARRAY; - } - - @Override - @Nonnull - public PsiTypeParameter[] getTypeParameters() { - return PsiTypeParameter.EMPTY_ARRAY; - } - - @Override - public PsiClass getSuperClass() { - return PsiClassImplUtil.getSuperClass(this); - } - - @Override - public PsiClass[] getInterfaces() { - return PsiClassImplUtil.getInterfaces(this); - } - - @Override - @Nonnull - public PsiClass[] getSupers() { - return PsiClassImplUtil.getSupers(this); - } - - @Override - @Nonnull - public PsiClassType[] getSuperTypes() { - return PsiClassImplUtil.getSuperTypes(this); - } - - @Override - public PsiClass getContainingClass() { - return null; - } - - @Override - @Nonnull - public Collection getVisibleSignatures() { - return PsiSuperMethodImplUtil.getVisibleSignatures(this); - } - - @Override - public PsiModifierList getModifierList() { - return null; - } - - @Override - public boolean hasModifierProperty(@Nonnull String name) { - return false; - } - - @Override - public PsiJavaToken getLBrace() { - return null; - } - - @Override - public PsiJavaToken getRBrace() { - return null; - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor) visitor).visitTypeParameter(this); - } else { - visitor.visitElement(this); - } - } - - @NonNls - public String toString() { - return "PsiTypeParameter:" + getName(); - } - - public PsiMetaData getMetaData() { - return MetaDataService.getInstance().getMeta(this); - } - - @Override - public boolean isEquivalentTo(final PsiElement another) { - return PsiClassImplUtil.isClassEquivalentTo(this, another); - } - - @Override - @Nonnull - public SearchScope getUseScope() { - return PsiClassImplUtil.getClassUseScope(this); - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - return getStubOrPsiChildren(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY); - } - - @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { - return PsiImplUtil.findAnnotation(this, qualifiedName); - } - - @Override - @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { - throw new IncorrectOperationException(); - } - - @Override - @Nonnull - public PsiAnnotation[] getApplicableAnnotations() { - return getAnnotations(); - } + private final LightEmptyImplementsList myLightEmptyImplementsList = new LightEmptyImplementsList(null) { + @Override + public PsiManager getManager() { + return PsiTypeParameterImpl.this.getManager(); + } + }; + + public PsiTypeParameterImpl(final PsiTypeParameterStub stub) { + super(stub, JavaStubElementTypes.TYPE_PARAMETER); + } + + public PsiTypeParameterImpl(final ASTNode node) { + super(node); + } + + @Override + public String getQualifiedName() { + return null; + } + + @Override + public boolean isInterface() { + return false; + } + + @Override + public boolean isAnnotationType() { + return false; + } + + @Override + public boolean isEnum() { + return false; + } + + @Override + @Nonnull + public PsiField[] getFields() { + return PsiField.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiMethod[] getMethods() { + return PsiMethod.EMPTY_ARRAY; + } + + @Override + public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) { + return PsiClassImplUtil.findMethodBySignature(this, patternMethod, checkBases); + } + + @Override + @Nonnull + public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) { + return PsiClassImplUtil.findMethodsBySignature(this, patternMethod, checkBases); + } + + @Override + public PsiField findFieldByName(String name, boolean checkBases) { + return PsiClassImplUtil.findFieldByName(this, name, checkBases); + } + + @Override + @Nonnull + public PsiMethod[] findMethodsByName(String name, boolean checkBases) { + return PsiClassImplUtil.findMethodsByName(this, name, checkBases); + } + + @Override + @Nonnull + public List> findMethodsAndTheirSubstitutorsByName(String name, boolean checkBases) { + return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); + } + + @Override + @Nonnull + public List> getAllMethodsAndTheirSubstitutors() { + return PsiClassImplUtil.getAllWithSubstitutorsByMap(this, PsiClassImplUtil.MemberType.METHOD); + } + + @Override + public PsiClass findInnerClassByName(String name, boolean checkBases) { + return PsiClassImplUtil.findInnerByName(this, name, checkBases); + } + + @Override + public PsiTypeParameterList getTypeParameterList() { + return null; + } + + @Override + public boolean hasTypeParameters() { + return false; + } + + // very special method! + @Override + public PsiElement getScope() { + return getParent().getParent(); + } + + @Override + public boolean isInheritorDeep(PsiClass baseClass, PsiClass classToByPass) { + return InheritanceImplUtil.isInheritorDeep(this, baseClass, classToByPass); + } + + @Override + public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { + return InheritanceImplUtil.isInheritor(this, baseClass, checkDeep); + } + + @Override + public PsiTypeParameterListOwner getOwner() { + final PsiElement parent = getParent(); + if (parent == null) { + throw new PsiInvalidElementAccessException(this); + } + final PsiElement parentParent = parent.getParent(); + if (!(parentParent instanceof PsiTypeParameterListOwner)) { + // Might be an error element; + return PsiTreeUtil.getParentOfType(this, PsiTypeParameterListOwner.class); + } + + return (PsiTypeParameterListOwner)parentParent; + } + + + @Override + public int getIndex() { + final PsiTypeParameterStub stub = getStub(); + if (stub != null) { + final PsiTypeParameterListStub parentStub = (PsiTypeParameterListStub)stub.getParentStub(); + return parentStub.getChildrenStubs().indexOf(stub); + } + + int ret = 0; + PsiElement element = getPrevSibling(); + while (element != null) { + if (element instanceof PsiTypeParameter) { + ret++; + } + element = element.getPrevSibling(); + } + return ret; + } + + @Override + @Nonnull + public PsiIdentifier getNameIdentifier() { + return PsiTreeUtil.getRequiredChildOfType(this, PsiIdentifier.class); + } + + @Override + public boolean processDeclarations( + @Nonnull PsiScopeProcessor processor, + @Nonnull ResolveState state, + PsiElement lastParent, + @Nonnull PsiElement place + ) { + return PsiClassImplUtil.processDeclarationsInClass( + this, + processor, + state, + null, + lastParent, + place, + PsiUtil.getLanguageLevel(place), + false + ); + } + + @Override + public String getName() { + final PsiTypeParameterStub stub = getStub(); + if (stub != null) { + return stub.getName(); + } + + return getNameIdentifier().getText(); + } + + @Override + public PsiElement setName(@Nonnull String name) throws IncorrectOperationException { + PsiImplUtil.setName(getNameIdentifier(), name); + return this; + } + + @Override + @Nonnull + public PsiMethod[] getConstructors() { + return PsiMethod.EMPTY_ARRAY; + } + + @Override + public PsiDocComment getDocComment() { + return null; + } + + @Override + public boolean isDeprecated() { + return false; + } + + @Override + @Nonnull + public PsiReferenceList getExtendsList() { + return getRequiredStubOrPsiChild(JavaStubElementTypes.EXTENDS_BOUND_LIST); + } + + @Override + public PsiReferenceList getImplementsList() { + return myLightEmptyImplementsList; + } + + @Override + @Nonnull + public PsiClassType[] getExtendsListTypes() { + return PsiClassImplUtil.getExtendsListTypes(this); + } + + @Override + @Nonnull + public PsiClassType[] getImplementsListTypes() { + return PsiClassType.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiClass[] getInnerClasses() { + return PsiClass.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiField[] getAllFields() { + return PsiField.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiMethod[] getAllMethods() { + return PsiMethod.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiClass[] getAllInnerClasses() { + return PsiClass.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiClassInitializer[] getInitializers() { + return PsiClassInitializer.EMPTY_ARRAY; + } + + @Override + @Nonnull + public PsiTypeParameter[] getTypeParameters() { + return PsiTypeParameter.EMPTY_ARRAY; + } + + @Override + public PsiClass getSuperClass() { + return PsiClassImplUtil.getSuperClass(this); + } + + @Override + public PsiClass[] getInterfaces() { + return PsiClassImplUtil.getInterfaces(this); + } + + @Override + @Nonnull + public PsiClass[] getSupers() { + return PsiClassImplUtil.getSupers(this); + } + + @Override + @Nonnull + public PsiClassType[] getSuperTypes() { + return PsiClassImplUtil.getSuperTypes(this); + } + + @Override + public PsiClass getContainingClass() { + return null; + } + + @Override + @Nonnull + public Collection getVisibleSignatures() { + return PsiSuperMethodImplUtil.getVisibleSignatures(this); + } + + @Override + public PsiModifierList getModifierList() { + return null; + } + + @Override + public boolean hasModifierProperty(@Nonnull String name) { + return false; + } + + @Override + public PsiJavaToken getLBrace() { + return null; + } + + @Override + public PsiJavaToken getRBrace() { + return null; + } + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitTypeParameter(this); + } + else { + visitor.visitElement(this); + } + } + + @NonNls + public String toString() { + return "PsiTypeParameter:" + getName(); + } + + public PsiMetaData getMetaData() { + return MetaDataService.getInstance().getMeta(this); + } + + @Override + public boolean isEquivalentTo(final PsiElement another) { + return PsiClassImplUtil.isClassEquivalentTo(this, another); + } + + @Override + @Nonnull + public SearchScope getUseScope() { + return PsiClassImplUtil.getClassUseScope(this); + } + + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + return getStubOrPsiChildren(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY); + } + + @Override + public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { + return PsiImplUtil.findAnnotation(this, qualifiedName); + } + + @Override + @Nonnull + public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + throw new IncorrectOperationException(); + } + + @Override + @Nonnull + public PsiAnnotation[] getApplicableAnnotations() { + return getAnnotations(); + } } From 9d6db10d72a319e215e0fac026f608ad969fdedd Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 21 May 2025 17:48:35 +0300 Subject: [PATCH 5/6] Reformatting PsiModifierList. --- .../java/language/psi/PsiModifierList.java | 72 +- .../java/language/psi/PsiTypeParameter.java | 88 ++- .../psi/impl/light/AbstractLightClass.java | 658 +++++++++--------- .../tree/java/PsiCompositeModifierList.java | 72 +- 4 files changed, 452 insertions(+), 438 deletions(-) diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java index 318307c958..56a949b794 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java @@ -27,43 +27,43 @@ * @see PsiModifierListOwner#getModifierList() */ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner { - /** - * Checks if the modifier list has the specified modifier set either by an explicit keyword - * or implicitly (for example, interface methods are implicitly public). - * - * @param name the name of the modifier to check. - * @return true if the list has the modifier, false otherwise - * @see #hasExplicitModifier(String) - */ - boolean hasModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name); + /** + * Checks if the modifier list has the specified modifier set either by an explicit keyword + * or implicitly (for example, interface methods are implicitly public). + * + * @param name the name of the modifier to check. + * @return true if the list has the modifier, false otherwise + * @see #hasExplicitModifier(String) + */ + boolean hasModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name); - /** - * Checks if the modifier list has the specified modifier set by an explicit keyword. - * - * @param name the name of the modifier to check. - * @return true if the list has the modifier, false otherwise - * @see #hasModifierProperty(String) - */ - boolean hasExplicitModifier(@PsiModifier.ModifierConstant @Nonnull @NonNls String name); + /** + * Checks if the modifier list has the specified modifier set by an explicit keyword. + * + * @param name the name of the modifier to check. + * @return true if the list has the modifier, false otherwise + * @see #hasModifierProperty(String) + */ + boolean hasExplicitModifier(@PsiModifier.ModifierConstant @Nonnull @NonNls String name); - /** - * Adds or removes the specified modifier to the modifier list. - * - * @param name the name of the modifier to add or remove. - * @param value true if the modifier should be added, false if it should be removed. - * @throws IncorrectOperationException if the modification fails for some reason. - */ - void setModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) throws IncorrectOperationException; - - /** - * Checks if it is possible to add or remove the specified modifier to the modifier list, - * and throws an exception if the operation is not possible. Does not actually modify - * anything. - * - * @param name the name of the modifier to check the add or remove possibility for. - * @param value true if the modifier should be added, false if it should be removed. - * @throws IncorrectOperationException if the modification fails for some reason. - */ - void checkSetModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) throws IncorrectOperationException; + /** + * Adds or removes the specified modifier to the modifier list. + * + * @param name the name of the modifier to add or remove. + * @param value true if the modifier should be added, false if it should be removed. + * @throws IncorrectOperationException if the modification fails for some reason. + */ + void setModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) throws IncorrectOperationException; + /** + * Checks if it is possible to add or remove the specified modifier to the modifier list, + * and throws an exception if the operation is not possible. Does not actually modify + * anything. + * + * @param name the name of the modifier to check the add or remove possibility for. + * @param value true if the modifier should be added, false if it should be removed. + * @throws IncorrectOperationException if the modification fails for some reason. + */ + void checkSetModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) + throws IncorrectOperationException; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java index abf9b0ef73..3ab670e143 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java @@ -27,57 +27,53 @@ * * @author dsl */ -public interface PsiTypeParameter extends PsiClass, PsiAnnotationOwner, JvmTypeParameter -{ - /** - * The empty array of PSI type parameters which can be reused to avoid unnecessary allocations. - */ - PsiTypeParameter[] EMPTY_ARRAY = new PsiTypeParameter[0]; +public interface PsiTypeParameter extends PsiClass, PsiAnnotationOwner, JvmTypeParameter { + /** + * The empty array of PSI type parameters which can be reused to avoid unnecessary allocations. + */ + PsiTypeParameter[] EMPTY_ARRAY = new PsiTypeParameter[0]; - ArrayFactory ARRAY_FACTORY = count -> count == 0 ? EMPTY_ARRAY : new PsiTypeParameter[count]; + ArrayFactory ARRAY_FACTORY = count -> count == 0 ? EMPTY_ARRAY : new PsiTypeParameter[count]; - /** - * Returns the extends list of the type parameter. - * - * @return the extends list. For this particular kind of classes it never returns null. - */ - @Override - @Nonnull - PsiReferenceList getExtendsList(); + /** + * Returns the extends list of the type parameter. + * + * @return the extends list. For this particular kind of classes it never returns null. + */ + @Override + @Nonnull + PsiReferenceList getExtendsList(); - /** - * Returns the element which is parameterized by the type parameter. - * - * @return the type parameter owner instance. - */ - @Nullable - @Override - PsiTypeParameterListOwner getOwner(); + /** + * Returns the element which is parameterized by the type parameter. + * + * @return the type parameter owner instance. + */ + @Nullable + @Override + PsiTypeParameterListOwner getOwner(); - /** - * Returns the position of this type parameter in the type parameter list of the owner element. - * - * @return the type parameter position. - */ - int getIndex(); + /** + * Returns the position of this type parameter in the type parameter list of the owner element. + * + * @return the type parameter position. + */ + int getIndex(); - @Nonnull - @Override - default PsiAnnotation[] getAnnotations() - { - return PsiClass.super.getAnnotations(); - } + @Nonnull + @Override + default PsiAnnotation[] getAnnotations() { + return PsiClass.super.getAnnotations(); + } - @Override - default boolean hasAnnotation(@Nonnull @NonNls String fqn) - { - return PsiClass.super.hasAnnotation(fqn); - } + @Override + default boolean hasAnnotation(@Nonnull @NonNls String fqn) { + return PsiClass.super.hasAnnotation(fqn); + } - @Nonnull - @Override - default JvmReferenceType[] getBounds() - { - return getExtendsList().getReferencedTypes(); - } + @Nonnull + @Override + default JvmReferenceType[] getBounds() { + return getExtendsList().getReferencedTypes(); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java index b4b4f71857..a41e337bb5 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java @@ -39,332 +39,344 @@ import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Collection; import java.util.List; public abstract class AbstractLightClass extends LightElement implements PsiClass { - protected AbstractLightClass(PsiManager manager, Language language) { - super(manager, language); - } - - protected AbstractLightClass(PsiManager manager) { - super(manager, JavaLanguage.INSTANCE); - } - - @Nonnull - public abstract PsiClass getDelegate(); - - @Nonnull - public abstract PsiElement copy(); - - @Override - @NonNls - @Nullable - public String getName() { - return getDelegate().getName(); - } - - @Override - @Nullable - public PsiModifierList getModifierList() { - return getDelegate().getModifierList(); - } - - @Override - public boolean hasModifierProperty(@NonNls @Nonnull String name) { - return getDelegate().hasModifierProperty(name); - } - - @Override - @Nullable - public PsiDocComment getDocComment() { - return null; - } - - @Override - public boolean isDeprecated() { - return getDelegate().isDeprecated(); - } - - @Override - public boolean hasTypeParameters() { - return PsiImplUtil.hasTypeParameters(this); - } - - @Override - @Nullable - public PsiTypeParameterList getTypeParameterList() { - return getDelegate().getTypeParameterList(); - } - - @Override - @Nonnull - public PsiTypeParameter[] getTypeParameters() { - return getDelegate().getTypeParameters(); - } - - @Override - @NonNls - @Nullable - public String getQualifiedName() { - return getDelegate().getQualifiedName(); - } - - @Override - public boolean isInterface() { - return getDelegate().isInterface(); - } - - @Override - public boolean isAnnotationType() { - return getDelegate().isAnnotationType(); - } - - @Override - public boolean isEnum() { - return getDelegate().isEnum(); - } - - @Override - @Nullable - public PsiReferenceList getExtendsList() { - return getDelegate().getExtendsList(); - } - - @Override - @Nullable - public PsiReferenceList getImplementsList() { - return getDelegate().getImplementsList(); - } - - @Override - @Nonnull - public PsiClassType[] getExtendsListTypes() { - return PsiClassImplUtil.getExtendsListTypes(this); - } - - @Override - @Nonnull - public PsiClassType[] getImplementsListTypes() { - return PsiClassImplUtil.getImplementsListTypes(this); - } - - @Override - @Nullable - public PsiClass getSuperClass() { - return getDelegate().getSuperClass(); - } - - @Override - public PsiClass[] getInterfaces() { - return getDelegate().getInterfaces(); - } - - @Nonnull - @Override - public PsiElement getNavigationElement() { - return getDelegate().getNavigationElement(); - } - - @Override - @Nonnull - public PsiClass[] getSupers() { - return getDelegate().getSupers(); - } - - @Override - @Nonnull - public PsiClassType[] getSuperTypes() { - return getDelegate().getSuperTypes(); - } - - @Override - @Nonnull - public PsiField[] getFields() { - return getDelegate().getFields(); - } - - @Override - @Nonnull - public PsiMethod[] getMethods() { - return getDelegate().getMethods(); - } - - @Override - @Nonnull - public PsiMethod[] getConstructors() { - return getDelegate().getConstructors(); - } - - @Override - @Nonnull - public PsiClass[] getInnerClasses() { - return getDelegate().getInnerClasses(); - } - - @Override - @Nonnull - public PsiClassInitializer[] getInitializers() { - return getDelegate().getInitializers(); - } - - @Override - public boolean processDeclarations(@Nonnull PsiScopeProcessor processor, - @Nonnull ResolveState state, - PsiElement lastParent, - @Nonnull PsiElement place) { - return PsiClassImplUtil.processDeclarationsInClass(this, processor, state, null, lastParent, place, PsiUtil.getLanguageLevel(place), false); - } - - @Override - @Nonnull - public PsiField[] getAllFields() { - return getDelegate().getAllFields(); - } - - @Override - @Nonnull - public PsiMethod[] getAllMethods() { - return getDelegate().getAllMethods(); - } - - @Override - @Nonnull - public PsiClass[] getAllInnerClasses() { - return getDelegate().getAllInnerClasses(); - } - - @Override - @Nullable - public PsiField findFieldByName(@NonNls String name, boolean checkBases) { - return PsiClassImplUtil.findFieldByName(this, name, checkBases); - } - - @Override - @Nullable - public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) { - return PsiClassImplUtil.findMethodBySignature(this, patternMethod, checkBases); - } - - @Override - @Nonnull - public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) { - return PsiClassImplUtil.findMethodsBySignature(this, patternMethod, checkBases); - } - - @Override - @Nonnull - public PsiMethod[] findMethodsByName(@NonNls String name, boolean checkBases) { - return PsiClassImplUtil.findMethodsByName(this, name, checkBases); - } - - @Override - @Nonnull - public List> findMethodsAndTheirSubstitutorsByName(@NonNls String name, boolean checkBases) { - return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); - } - - @Override - @Nonnull - public List> getAllMethodsAndTheirSubstitutors() { - return PsiClassImplUtil.getAllWithSubstitutorsByMap(this, PsiClassImplUtil.MemberType.METHOD); - } - - @Override - @Nullable - public PsiClass findInnerClassByName(@NonNls String name, boolean checkBases) { - return getDelegate().findInnerClassByName(name, checkBases); - } - - @Override - @Nullable - public PsiElement getLBrace() { - return getDelegate().getLBrace(); - } - - @Override - @Nullable - public PsiElement getRBrace() { - return getDelegate().getRBrace(); - } - - @Override - @Nullable - public PsiIdentifier getNameIdentifier() { - return getDelegate().getNameIdentifier(); - } - - @Override - public PsiElement getScope() { - return getDelegate().getScope(); - } - - @Override - public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { - return getDelegate().isInheritor(baseClass, checkDeep); - } - - @Override - public boolean isInheritorDeep(PsiClass baseClass, @Nullable PsiClass classToByPass) { - return getDelegate().isInheritorDeep(baseClass, classToByPass); - } - - @Override - @Nullable - public PsiClass getContainingClass() { - return getDelegate().getContainingClass(); - } - - @Override - @Nonnull - public Collection getVisibleSignatures() { - return getDelegate().getVisibleSignatures(); - } - - @Override - public PsiElement setName(@NonNls @Nonnull String name) throws IncorrectOperationException { - return getDelegate().setName(name); - } - - @Override - public String toString() { - return "PsiClass:" + getName(); - } - - @Override - public String getText() { - return getDelegate().getText(); - } - - @Override - public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitClass(this); - } else { - visitor.visitElement(this); - } - } - - @Override - public PsiFile getContainingFile() { - return getDelegate().getContainingFile(); - } - - @Override - public PsiElement getContext() { - return getDelegate(); - } - - @Override - public boolean isValid() { - return getDelegate().isValid(); - } - - @Override - public boolean isEquivalentTo(PsiElement another) { - return this == another || - (another instanceof AbstractLightClass && getDelegate().isEquivalentTo(((AbstractLightClass)another).getDelegate())) || - getDelegate().isEquivalentTo(another); - } + protected AbstractLightClass(PsiManager manager, Language language) { + super(manager, language); + } + + protected AbstractLightClass(PsiManager manager) { + super(manager, JavaLanguage.INSTANCE); + } + + @Nonnull + public abstract PsiClass getDelegate(); + + @Nonnull + public abstract PsiElement copy(); + + @Override + @NonNls + @Nullable + public String getName() { + return getDelegate().getName(); + } + + @Override + @Nullable + public PsiModifierList getModifierList() { + return getDelegate().getModifierList(); + } + + @Override + public boolean hasModifierProperty(@NonNls @Nonnull String name) { + return getDelegate().hasModifierProperty(name); + } + + @Override + @Nullable + public PsiDocComment getDocComment() { + return null; + } + + @Override + public boolean isDeprecated() { + return getDelegate().isDeprecated(); + } + + @Override + public boolean hasTypeParameters() { + return PsiImplUtil.hasTypeParameters(this); + } + + @Override + @Nullable + public PsiTypeParameterList getTypeParameterList() { + return getDelegate().getTypeParameterList(); + } + + @Override + @Nonnull + public PsiTypeParameter[] getTypeParameters() { + return getDelegate().getTypeParameters(); + } + + @Override + @NonNls + @Nullable + public String getQualifiedName() { + return getDelegate().getQualifiedName(); + } + + @Override + public boolean isInterface() { + return getDelegate().isInterface(); + } + + @Override + public boolean isAnnotationType() { + return getDelegate().isAnnotationType(); + } + + @Override + public boolean isEnum() { + return getDelegate().isEnum(); + } + + @Override + @Nullable + public PsiReferenceList getExtendsList() { + return getDelegate().getExtendsList(); + } + + @Override + @Nullable + public PsiReferenceList getImplementsList() { + return getDelegate().getImplementsList(); + } + + @Override + @Nonnull + public PsiClassType[] getExtendsListTypes() { + return PsiClassImplUtil.getExtendsListTypes(this); + } + + @Override + @Nonnull + public PsiClassType[] getImplementsListTypes() { + return PsiClassImplUtil.getImplementsListTypes(this); + } + + @Override + @Nullable + public PsiClass getSuperClass() { + return getDelegate().getSuperClass(); + } + + @Override + public PsiClass[] getInterfaces() { + return getDelegate().getInterfaces(); + } + + @Nonnull + @Override + public PsiElement getNavigationElement() { + return getDelegate().getNavigationElement(); + } + + @Override + @Nonnull + public PsiClass[] getSupers() { + return getDelegate().getSupers(); + } + + @Override + @Nonnull + public PsiClassType[] getSuperTypes() { + return getDelegate().getSuperTypes(); + } + + @Override + @Nonnull + public PsiField[] getFields() { + return getDelegate().getFields(); + } + + @Override + @Nonnull + public PsiMethod[] getMethods() { + return getDelegate().getMethods(); + } + + @Override + @Nonnull + public PsiMethod[] getConstructors() { + return getDelegate().getConstructors(); + } + + @Override + @Nonnull + public PsiClass[] getInnerClasses() { + return getDelegate().getInnerClasses(); + } + @Override + @Nonnull + public PsiClassInitializer[] getInitializers() { + return getDelegate().getInitializers(); + } + + @Override + public boolean processDeclarations( + @Nonnull PsiScopeProcessor processor, + @Nonnull ResolveState state, + PsiElement lastParent, + @Nonnull PsiElement place + ) { + return PsiClassImplUtil.processDeclarationsInClass( + this, + processor, + state, + null, + lastParent, + place, + PsiUtil.getLanguageLevel(place), + false + ); + } + + @Override + @Nonnull + public PsiField[] getAllFields() { + return getDelegate().getAllFields(); + } + + @Override + @Nonnull + public PsiMethod[] getAllMethods() { + return getDelegate().getAllMethods(); + } + + @Override + @Nonnull + public PsiClass[] getAllInnerClasses() { + return getDelegate().getAllInnerClasses(); + } + + @Override + @Nullable + public PsiField findFieldByName(@NonNls String name, boolean checkBases) { + return PsiClassImplUtil.findFieldByName(this, name, checkBases); + } + + @Override + @Nullable + public PsiMethod findMethodBySignature(PsiMethod patternMethod, boolean checkBases) { + return PsiClassImplUtil.findMethodBySignature(this, patternMethod, checkBases); + } + + @Override + @Nonnull + public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean checkBases) { + return PsiClassImplUtil.findMethodsBySignature(this, patternMethod, checkBases); + } + + @Override + @Nonnull + public PsiMethod[] findMethodsByName(@NonNls String name, boolean checkBases) { + return PsiClassImplUtil.findMethodsByName(this, name, checkBases); + } + + @Override + @Nonnull + public List> findMethodsAndTheirSubstitutorsByName(@NonNls String name, boolean checkBases) { + return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); + } + + @Override + @Nonnull + public List> getAllMethodsAndTheirSubstitutors() { + return PsiClassImplUtil.getAllWithSubstitutorsByMap(this, PsiClassImplUtil.MemberType.METHOD); + } + + @Override + @Nullable + public PsiClass findInnerClassByName(@NonNls String name, boolean checkBases) { + return getDelegate().findInnerClassByName(name, checkBases); + } + + @Override + @Nullable + public PsiElement getLBrace() { + return getDelegate().getLBrace(); + } + + @Override + @Nullable + public PsiElement getRBrace() { + return getDelegate().getRBrace(); + } + + @Override + @Nullable + public PsiIdentifier getNameIdentifier() { + return getDelegate().getNameIdentifier(); + } + + @Override + public PsiElement getScope() { + return getDelegate().getScope(); + } + + @Override + public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { + return getDelegate().isInheritor(baseClass, checkDeep); + } + + @Override + public boolean isInheritorDeep(PsiClass baseClass, @Nullable PsiClass classToByPass) { + return getDelegate().isInheritorDeep(baseClass, classToByPass); + } + + @Override + @Nullable + public PsiClass getContainingClass() { + return getDelegate().getContainingClass(); + } + + @Override + @Nonnull + public Collection getVisibleSignatures() { + return getDelegate().getVisibleSignatures(); + } + + @Override + public PsiElement setName(@NonNls @Nonnull String name) throws IncorrectOperationException { + return getDelegate().setName(name); + } + + @Override + public String toString() { + return "PsiClass:" + getName(); + } + + @Override + public String getText() { + return getDelegate().getText(); + } + + @Override + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitClass(this); + } + else { + visitor.visitElement(this); + } + } + + @Override + public PsiFile getContainingFile() { + return getDelegate().getContainingFile(); + } + + @Override + public PsiElement getContext() { + return getDelegate(); + } + + @Override + public boolean isValid() { + return getDelegate().isValid(); + } + + @Override + public boolean isEquivalentTo(PsiElement another) { + return this == another || + (another instanceof AbstractLightClass && getDelegate().isEquivalentTo(((AbstractLightClass)another).getDelegate())) || + getDelegate().isEquivalentTo(another); + } } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java index 416ee3a999..18051238d8 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java @@ -30,46 +30,52 @@ import java.util.List; public class PsiCompositeModifierList extends LightModifierList { - private final List mySublists; + private final List mySublists; - public PsiCompositeModifierList(final PsiManager manager, List sublists) { - super(manager); - mySublists = sublists; - } - - @Override - @Nonnull - public PsiAnnotation[] getAnnotations() { - List annotations = new ArrayList(); - for (PsiModifierList list : mySublists) { - ContainerUtil.addAll(annotations, list.getAnnotations()); + public PsiCompositeModifierList(final PsiManager manager, List sublists) { + super(manager); + mySublists = sublists; } - return annotations.toArray(new PsiAnnotation[annotations.size()]); - } - @Override - public PsiAnnotation findAnnotation(@Nonnull final String qualifiedName) { - for (PsiModifierList sublist : mySublists) { - final PsiAnnotation annotation = sublist.findAnnotation(qualifiedName); - if (annotation != null) return annotation; + @Override + @Nonnull + public PsiAnnotation[] getAnnotations() { + List annotations = new ArrayList(); + for (PsiModifierList list : mySublists) { + ContainerUtil.addAll(annotations, list.getAnnotations()); + } + return annotations.toArray(new PsiAnnotation[annotations.size()]); } - return null; - } + @Override + public PsiAnnotation findAnnotation(@Nonnull final String qualifiedName) { + for (PsiModifierList sublist : mySublists) { + final PsiAnnotation annotation = sublist.findAnnotation(qualifiedName); + if (annotation != null) { + return annotation; + } + } + + return null; + } - @Override - public boolean hasModifierProperty(@Nonnull final String name) { - for (PsiModifierList sublist : mySublists) { - if (sublist.hasModifierProperty(name)) return true; + @Override + public boolean hasModifierProperty(@Nonnull final String name) { + for (PsiModifierList sublist : mySublists) { + if (sublist.hasModifierProperty(name)) { + return true; + } + } + return false; } - return false; - } - @Override - public boolean hasExplicitModifier(@Nonnull final String name) { - for (PsiModifierList sublist : mySublists) { - if (sublist.hasExplicitModifier(name)) return true; + @Override + public boolean hasExplicitModifier(@Nonnull final String name) { + for (PsiModifierList sublist : mySublists) { + if (sublist.hasExplicitModifier(name)) { + return true; + } + } + return false; } - return false; - } } From 8edc24a86012fec0ecc64e18d1555f252e4953b8 Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 21 May 2025 18:23:47 +0300 Subject: [PATCH 6/6] Refactoring descendants of PsiAnnotationOwner. --- .../java/language/psi/PsiModifierList.java | 11 +- .../intellij/java/language/psi/PsiType.java | 14 +- .../java/language/psi/PsiTypeParameter.java | 7 +- .../language/impl/psi/impl/PsiImplUtil.java | 10 +- .../impl/compiled/ClsModifierListImpl.java | 17 ++- .../psi/impl/compiled/ClsTypeElementImpl.java | 81 ++++++------ .../impl/compiled/ClsTypeParameterImpl.java | 25 ++-- .../psi/impl/light/AbstractLightClass.java | 29 ++-- .../psi/impl/light/LightModifierList.java | 13 +- .../impl/psi/impl/light/LightTypeElement.java | 16 ++- .../psi/impl/light/LightTypeParameter.java | 15 ++- .../impl/light/LightTypeParameterBuilder.java | 5 +- .../psi/impl/source/PsiModifierListImpl.java | 90 +++++++------ .../psi/impl/source/PsiTypeElementImpl.java | 124 +++++++++--------- .../graphInference/InferenceVariable.java | 5 +- .../tree/java/PsiCompositeModifierList.java | 21 +-- .../tree/java/PsiTypeParameterImpl.java | 46 ++++--- 17 files changed, 288 insertions(+), 241 deletions(-) diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java index 56a949b794..25019ca39b 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiModifierList.java @@ -15,10 +15,10 @@ */ package com.intellij.java.language.psi; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiElement; import consulo.language.util.IncorrectOperationException; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; /** * Represents the list of modifiers and annotations on a Java element (class, method, @@ -35,7 +35,8 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner { * @return true if the list has the modifier, false otherwise * @see #hasExplicitModifier(String) */ - boolean hasModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name); + @RequiredReadAction + boolean hasModifierProperty(@PsiModifier.ModifierConstant @Nonnull String name); /** * Checks if the modifier list has the specified modifier set by an explicit keyword. @@ -44,7 +45,7 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner { * @return true if the list has the modifier, false otherwise * @see #hasModifierProperty(String) */ - boolean hasExplicitModifier(@PsiModifier.ModifierConstant @Nonnull @NonNls String name); + boolean hasExplicitModifier(@PsiModifier.ModifierConstant @Nonnull String name); /** * Adds or removes the specified modifier to the modifier list. @@ -53,7 +54,7 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner { * @param value true if the modifier should be added, false if it should be removed. * @throws IncorrectOperationException if the modification fails for some reason. */ - void setModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) throws IncorrectOperationException; + void setModifierProperty(@PsiModifier.ModifierConstant @Nonnull String name, boolean value) throws IncorrectOperationException; /** * Checks if it is possible to add or remove the specified modifier to the modifier list, @@ -64,6 +65,6 @@ public interface PsiModifierList extends PsiElement, PsiAnnotationOwner { * @param value true if the modifier should be added, false if it should be removed. * @throws IncorrectOperationException if the modification fails for some reason. */ - void checkSetModifierProperty(@PsiModifier.ModifierConstant @Nonnull @NonNls String name, boolean value) + void checkSetModifierProperty(@PsiModifier.ModifierConstant @Nonnull String name, boolean value) throws IncorrectOperationException; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java index aebf6bbb72..ce5f528f70 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiType.java @@ -62,7 +62,7 @@ public static PsiType[] createArray(int count) { /** * Constructs a PsiType with given annotations */ - protected PsiType(@Nonnull final PsiAnnotation[] annotations) { + protected PsiType(@Nonnull PsiAnnotation[] annotations) { this(TypeAnnotationProvider.Static.create(annotations)); } @@ -145,7 +145,7 @@ public String getInternalCanonicalText() { * Checks if the type is currently valid. * * @return true if the type is valid, false otherwise. - * @see PsiElement#isValid() + * @see consulo.language.psi.PsiElement#isValid() */ public abstract boolean isValid(); @@ -175,7 +175,7 @@ public boolean isConvertibleFrom(@Nonnull PsiType type) { * Returns the class type for qualified class name. * * @param qName qualified class name. - * @param project + * @param project current project. * @param resolveScope the scope in which the class is searched. * @return the class instance. */ @@ -272,9 +272,9 @@ public static PsiClassType getJavaLangRuntimeException(@Nonnull PsiManager manag public final int getArrayDimensions() { PsiType type = this; int dims = 0; - while (type instanceof PsiArrayType) { + while (type instanceof PsiArrayType arrayType) { dims++; - type = ((PsiArrayType)type).getComponentType(); + type = arrayType.getComponentType(); } return dims; } @@ -288,8 +288,8 @@ public final int getArrayDimensions() { @Nonnull public final PsiType getDeepComponentType() { PsiType type = this; - while (type instanceof PsiArrayType) { - type = ((PsiArrayType)type).getComponentType(); + while (type instanceof PsiArrayType arrayType) { + type = arrayType.getComponentType(); } return type; } diff --git a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java index 3ab670e143..16b1c489a7 100644 --- a/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java +++ b/java-language-api/src/main/java/com/intellij/java/language/psi/PsiTypeParameter.java @@ -18,9 +18,8 @@ import com.intellij.java.language.jvm.JvmTypeParameter; import com.intellij.java.language.jvm.types.JvmReferenceType; import consulo.util.collection.ArrayFactory; -import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; +import jakarta.annotation.Nullable; /** * Represents the type parameter of a generic class, interface, method or constructor. @@ -40,8 +39,8 @@ public interface PsiTypeParameter extends PsiClass, PsiAnnotationOwner, JvmTypeP * * @return the extends list. For this particular kind of classes it never returns null. */ - @Override @Nonnull + @Override PsiReferenceList getExtendsList(); /** @@ -67,7 +66,7 @@ default PsiAnnotation[] getAnnotations() { } @Override - default boolean hasAnnotation(@Nonnull @NonNls String fqn) { + default boolean hasAnnotation(@Nonnull String fqn) { return PsiClass.super.hasAnnotation(fqn); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java index e1c1cb384e..8cac1eb003 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/PsiImplUtil.java @@ -214,6 +214,7 @@ public static int getTypeParameterIndex(@Nonnull PsiTypeParameter typeParameter, } @Nonnull + @RequiredReadAction public static Object[] getReferenceVariantsByFilter(@Nonnull PsiJavaCodeReferenceElement reference, @Nonnull ElementFilter filter) { FilterScopeProcessor processor = new FilterScopeProcessor(filter); PsiScopesUtil.resolveAndWalk(processor, reference, null, true); @@ -383,6 +384,7 @@ public static PsiAnnotation findAnnotation(@Nullable PsiAnnotationOwner annotati * @deprecated use {@link AnnotationTargetUtil#findAnnotationTarget(PsiAnnotation, TargetType...)} (to be removed ion IDEA 17) */ @SuppressWarnings("unused") + @RequiredReadAction public static TargetType findApplicableTarget(@Nonnull PsiAnnotation annotation, @Nonnull TargetType... types) { return AnnotationTargetUtil.findAnnotationTarget(annotation, types); } @@ -391,6 +393,7 @@ public static TargetType findApplicableTarget(@Nonnull PsiAnnotation annotation, * @deprecated use {@link AnnotationTargetUtil#findAnnotationTarget(PsiClass, TargetType...)} (to be removed ion IDEA 17) */ @SuppressWarnings("unused") + @RequiredReadAction public static TargetType findApplicableTarget(@Nonnull PsiClass annotationType, @Nonnull TargetType... types) { return AnnotationTargetUtil.findAnnotationTarget(annotationType, types); } @@ -399,6 +402,7 @@ public static TargetType findApplicableTarget(@Nonnull PsiClass annotationType, * @deprecated use {@link AnnotationTargetUtil#getAnnotationTargets(PsiClass)} (to be removed ion IDEA 17) */ @SuppressWarnings("unused") + @RequiredReadAction public static Set getAnnotationTargets(@Nonnull PsiClass annotationType) { return AnnotationTargetUtil.getAnnotationTargets(annotationType); } @@ -744,10 +748,12 @@ public static PsiModifierList findNeighbourModifierList(@Nonnull PsiJavaCodeRefe return null; } + @RequiredReadAction public static boolean isTypeAnnotation(@Nullable PsiElement element) { return element instanceof PsiAnnotation annotation && AnnotationTargetUtil.isTypeAnnotation(annotation); } + @RequiredReadAction public static void collectTypeUseAnnotations(@Nonnull PsiModifierList modifierList, @Nonnull List annotations) { for (PsiAnnotation annotation : modifierList.getAnnotations()) { if (AnnotationTargetUtil.isTypeAnnotation(annotation)) { @@ -760,6 +766,7 @@ public static void collectTypeUseAnnotations(@Nonnull PsiModifierList modifierLi * @deprecated use {@link #collectTypeUseAnnotations(PsiModifierList, List)} (to be removed in IDEA 16) */ @SuppressWarnings("unused") + @RequiredReadAction public static List getTypeUseAnnotations(@Nonnull PsiModifierList modifierList) { SmartList result = null; @@ -789,7 +796,7 @@ public static void markTypeAnnotations(@Nonnull PsiTypeElement typeElement) { } } - @RequiredReadAction + @RequiredWriteAction public static void deleteTypeAnnotations(@Nonnull PsiTypeElement typeElement) { PsiElement left = PsiTreeUtil.skipSiblingsBackward(typeElement, PsiComment.class, PsiWhiteSpace.class, PsiTypeParameterList.class); if (left instanceof PsiModifierList modifierList) { @@ -809,6 +816,7 @@ public static boolean isLeafElementOfType(PsiElement element, TokenSet tokenSet) return element instanceof LeafElement leafElement && tokenSet.contains(leafElement.getElementType()); } + @RequiredReadAction public static PsiType buildTypeFromTypeString(@Nonnull String typeName, @Nonnull PsiElement context, @Nonnull PsiFile psiFile) { PsiType resultType; PsiManager psiManager = psiFile.getManager(); diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java index e2ada5b4ea..255292ddc7 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsModifierListImpl.java @@ -21,6 +21,7 @@ import com.intellij.java.language.impl.psi.impl.java.stubs.PsiModifierListStub; import com.intellij.java.language.impl.psi.impl.source.tree.JavaElementType; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.language.impl.ast.TreeElement; import consulo.language.impl.psi.SourceTreeToPsiMap; import consulo.language.psi.PsiElement; @@ -34,18 +35,21 @@ public ClsModifierListImpl(PsiModifierListStub stub) { super(stub); } - @Override @Nonnull + @Override + @RequiredReadAction public PsiElement[] getChildren() { return getAnnotations(); } @Override + @RequiredReadAction public boolean hasModifierProperty(@Nonnull String name) { return ModifierFlags.hasModifierProperty(name, getStub().getModifiersMask()); } @Override + @RequiredReadAction public boolean hasExplicitModifier(@Nonnull String name) { return hasModifierProperty(name); } @@ -84,6 +88,7 @@ public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { } @Override + @RequiredReadAction public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { PsiElement parent = getParent(); PsiAnnotation[] annotations = getAnnotations(); @@ -99,11 +104,11 @@ public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { boolean isClass = parent instanceof PsiClass; boolean isInterface = isClass && ((PsiClass)parent).isInterface(); boolean isEnum = isClass && ((PsiClass)parent).isEnum(); - boolean isInterfaceClass = isClass && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface(); + boolean isInterfaceClass = isClass && parent.getParent() instanceof PsiClass outerClass && outerClass.isInterface(); boolean isMethod = parent instanceof PsiMethod; - boolean isInterfaceMethod = isMethod && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface(); + boolean isInterfaceMethod = isMethod && parent.getParent() instanceof PsiClass psiClass && psiClass.isInterface(); boolean isField = parent instanceof PsiField; - boolean isInterfaceField = isField && parent.getParent() instanceof PsiClass && ((PsiClass)parent.getParent()).isInterface(); + boolean isInterfaceField = isField && parent.getParent() instanceof PsiClass psiClass && psiClass.isInterface(); boolean isEnumConstant = parent instanceof PsiEnumConstant; if (hasModifierProperty(PsiModifier.PUBLIC) && !isInterfaceMethod && !isInterfaceField && !isInterfaceClass && !isEnumConstant) { @@ -158,8 +163,8 @@ public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorExceptio @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitModifierList(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitModifierList(this); } else { visitor.visitElement(this); diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java index d3852d5ba6..06c67095a6 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeElementImpl.java @@ -8,6 +8,7 @@ import com.intellij.java.language.impl.psi.impl.source.PsiClassReferenceType; import com.intellij.java.language.impl.psi.impl.source.tree.JavaElementType; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.application.util.AtomicNotNullLazyValue; import consulo.application.util.AtomicNullableLazyValue; import consulo.application.util.NotNullLazyValue; @@ -58,7 +59,7 @@ public ClsTypeElementImpl(@Nonnull PsiElement parent, @Nonnull String typeText, myTypeText = TypeInfo.internFrequentType(typeText); myVariance = variance; myAnnotations = annotations; - myChild = new AtomicNullableLazyValue() { + myChild = new AtomicNullableLazyValue<>() { @Override protected ClsElementImpl compute() { return calculateChild(); @@ -67,8 +68,9 @@ protected ClsElementImpl compute() { myCachedType = AtomicNotNullLazyValue.createValue(this::calculateType); } - @Override @Nonnull + @Override + @RequiredReadAction public PsiElement[] getChildren() { ClsElementImpl child = myChild.getValue(); return child != null ? new PsiElement[]{child} : PsiElement.EMPTY_ARRAY; @@ -80,12 +82,13 @@ public PsiElement getParent() { } @Override + @RequiredReadAction public String getText() { - final String shortClassName = PsiNameHelper.getShortClassName(myTypeText); + String shortClassName = PsiNameHelper.getShortClassName(myTypeText); return decorateTypeText(shortClassName); } - private String decorateTypeText(final String shortClassName) { + private String decorateTypeText(String shortClassName) { switch (myVariance) { case VARIANCE_NONE: return shortClassName; @@ -201,11 +204,13 @@ private PsiType createArrayType(PsiTypeElement deepestChild) { } @Nonnull + @RequiredReadAction private PsiType calculateType() { return calculateBaseType().annotate(myAnnotations.getProvider(this)); } @Nonnull + @RequiredReadAction private PsiType calculateBaseType() { PsiType result = PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText); if (result != null) { @@ -213,46 +218,39 @@ private PsiType calculateBaseType() { } ClsElementImpl childElement = myChild.getValue(); - if (childElement instanceof ClsTypeElementImpl) { + if (childElement instanceof ClsTypeElementImpl typeElement) { if (isArray()) { - switch (myVariance) { - case VARIANCE_NONE: - return createArrayType((PsiTypeElement)childElement); - case VARIANCE_EXTENDS: - return PsiWildcardType.createExtends(getManager(), ((PsiTypeElement)childElement).getType()); - case VARIANCE_SUPER: - return PsiWildcardType.createSuper(getManager(), ((PsiTypeElement)childElement).getType()); - default: + return switch (myVariance) { + case VARIANCE_NONE -> createArrayType(typeElement); + case VARIANCE_EXTENDS -> PsiWildcardType.createExtends(getManager(), typeElement.getType()); + case VARIANCE_SUPER -> PsiWildcardType.createSuper(getManager(), typeElement.getType()); + default -> { assert false : myVariance; - return null; - } - } - else { - assert isVarArgs() : this; - return createArrayType((PsiTypeElement)childElement); + yield null; + } + }; } + assert isVarArgs() : this; + return createArrayType(typeElement); } - if (childElement instanceof ClsJavaCodeReferenceElementImpl) { - PsiClassReferenceType psiClassReferenceType = new PsiClassReferenceType((PsiJavaCodeReferenceElement)childElement, null); - switch (myVariance) { - case VARIANCE_NONE: - return psiClassReferenceType; - case VARIANCE_EXTENDS: - return PsiWildcardType.createExtends( - getManager(), - psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(childElement)) - ); - case VARIANCE_SUPER: - return PsiWildcardType.createSuper( - getManager(), - psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(childElement)) - ); - case VARIANCE_INVARIANT: - return PsiWildcardType.createUnbounded(getManager()); - default: + if (childElement instanceof ClsJavaCodeReferenceElementImpl codeRefElem) { + PsiClassReferenceType psiClassReferenceType = new PsiClassReferenceType(codeRefElem, null); + return switch (myVariance) { + case VARIANCE_NONE -> psiClassReferenceType; + case VARIANCE_EXTENDS -> PsiWildcardType.createExtends( + getManager(), + psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(codeRefElem)) + ); + case VARIANCE_SUPER -> PsiWildcardType.createSuper( + getManager(), + psiClassReferenceType.annotate(myAnnotations.forBound().getProvider(codeRefElem)) + ); + case VARIANCE_INVARIANT -> PsiWildcardType.createUnbounded(getManager()); + default -> { assert false : myVariance; - return null; - } + yield null; + } + }; } assert childElement == null : this; return PsiWildcardType.createUnbounded(getManager()); @@ -260,8 +258,8 @@ private PsiType calculateBaseType() { @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeElement(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitTypeElement(this); } else { visitor.visitElement(this); @@ -292,6 +290,7 @@ public PsiAnnotation[] getApplicableAnnotations() { } @Override + @RequiredReadAction public String toString() { return "PsiTypeElement:" + getText(); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java index 53a8e71aa6..1d423ebecc 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/compiled/ClsTypeParameterImpl.java @@ -24,6 +24,7 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.javadoc.PsiDocComment; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; import consulo.content.scope.SearchScope; import consulo.language.impl.ast.TreeElement; import consulo.language.impl.psi.SourceTreeToPsiMap; @@ -36,8 +37,6 @@ import consulo.language.psi.resolve.ResolveState; import consulo.language.util.IncorrectOperationException; import consulo.util.lang.Pair; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import java.util.Collection; @@ -157,6 +156,7 @@ public PsiIdentifier getNameIdentifier() { } @Override + @RequiredReadAction public boolean processDeclarations( @Nonnull PsiScopeProcessor processor, @Nonnull ResolveState state, @@ -176,6 +176,7 @@ public boolean processDeclarations( } @Override + @RequiredReadAction public String getName() { return getStub().getName(); } @@ -265,6 +266,7 @@ public PsiClass getSuperClass() { return PsiClassImplUtil.getSuperClass(this); } + @Nonnull @Override public PsiClass[] getInterfaces() { return PsiClassImplUtil.getInterfaces(this); @@ -315,20 +317,21 @@ public PsiJavaToken getRBrace() { @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitTypeParameter(this); } else { visitor.visitElement(this); } } - @NonNls + @Override public String toString() { return "PsiTypeParameter"; } @Override + @RequiredReadAction public void appendMirrorText(int indentLevel, @Nonnull StringBuilder buffer) { buffer.append(getName()); @@ -350,8 +353,9 @@ public void setMirror(@Nonnull TreeElement element) throws InvalidMirrorExceptio setMirror(getExtendsList(), SourceTreeToPsiMap.treeToPsiNotNull(element).getExtendsList()); } - @Override @Nonnull + @Override + @RequiredReadAction public PsiElement[] getChildren() { return PsiElement.EMPTY_ARRAY; } @@ -363,16 +367,17 @@ public PsiTypeParameterListOwner getOwner() { @Override public int getIndex() { - final PsiTypeParameterStub stub = getStub(); + PsiTypeParameterStub stub = getStub(); return stub.getParentStub().getChildrenStubs().indexOf(stub); } + @Override public PsiMetaData getMetaData() { return MetaDataService.getInstance().getMeta(this); } @Override - public boolean isEquivalentTo(final PsiElement another) { + public boolean isEquivalentTo(PsiElement another) { return PsiClassImplUtil.isClassEquivalentTo(this, another); } @@ -390,13 +395,13 @@ public PsiAnnotation[] getAnnotations() { } @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { return null; } @Override @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { throw new IncorrectOperationException(); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java index a41e337bb5..cf5db2d13b 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/AbstractLightClass.java @@ -25,6 +25,8 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.javadoc.PsiDocComment; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.Language; import consulo.language.impl.psi.LightElement; import consulo.language.psi.PsiElement; @@ -56,11 +58,12 @@ protected AbstractLightClass(PsiManager manager) { public abstract PsiClass getDelegate(); @Nonnull + @Override public abstract PsiElement copy(); - @Override - @NonNls @Nullable + @Override + @RequiredReadAction public String getName() { return getDelegate().getName(); } @@ -72,7 +75,7 @@ public PsiModifierList getModifierList() { } @Override - public boolean hasModifierProperty(@NonNls @Nonnull String name) { + public boolean hasModifierProperty(@Nonnull String name) { return getDelegate().hasModifierProperty(name); } @@ -104,9 +107,8 @@ public PsiTypeParameter[] getTypeParameters() { return getDelegate().getTypeParameters(); } - @Override - @NonNls @Nullable + @Override public String getQualifiedName() { return getDelegate().getQualifiedName(); } @@ -126,8 +128,8 @@ public boolean isEnum() { return getDelegate().isEnum(); } - @Override @Nullable + @Override public PsiReferenceList getExtendsList() { return getDelegate().getExtendsList(); } @@ -156,6 +158,7 @@ public PsiClass getSuperClass() { return getDelegate().getSuperClass(); } + @Nonnull @Override public PsiClass[] getInterfaces() { return getDelegate().getInterfaces(); @@ -210,6 +213,7 @@ public PsiClassInitializer[] getInitializers() { } @Override + @RequiredReadAction public boolean processDeclarations( @Nonnull PsiScopeProcessor processor, @Nonnull ResolveState state, @@ -248,7 +252,7 @@ public PsiClass[] getAllInnerClasses() { @Override @Nullable - public PsiField findFieldByName(@NonNls String name, boolean checkBases) { + public PsiField findFieldByName(String name, boolean checkBases) { return PsiClassImplUtil.findFieldByName(this, name, checkBases); } @@ -266,13 +270,13 @@ public PsiMethod[] findMethodsBySignature(PsiMethod patternMethod, boolean check @Override @Nonnull - public PsiMethod[] findMethodsByName(@NonNls String name, boolean checkBases) { + public PsiMethod[] findMethodsByName(String name, boolean checkBases) { return PsiClassImplUtil.findMethodsByName(this, name, checkBases); } @Override @Nonnull - public List> findMethodsAndTheirSubstitutorsByName(@NonNls String name, boolean checkBases) { + public List> findMethodsAndTheirSubstitutorsByName(String name, boolean checkBases) { return PsiClassImplUtil.findMethodsAndTheirSubstitutorsByName(this, name, checkBases); } @@ -284,7 +288,7 @@ public List> getAllMethodsAndTheirSubstitutors() @Override @Nullable - public PsiClass findInnerClassByName(@NonNls String name, boolean checkBases) { + public PsiClass findInnerClassByName(String name, boolean checkBases) { return getDelegate().findInnerClassByName(name, checkBases); } @@ -334,16 +338,19 @@ public Collection getVisibleSignatures() { } @Override - public PsiElement setName(@NonNls @Nonnull String name) throws IncorrectOperationException { + @RequiredWriteAction + public PsiElement setName(@Nonnull String name) throws IncorrectOperationException { return getDelegate().setName(name); } @Override + @RequiredReadAction public String toString() { return "PsiClass:" + getName(); } @Override + @RequiredReadAction public String getText() { return getDelegate().getText(); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java index f2703b95c7..785c2f2f2b 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightModifierList.java @@ -17,14 +17,13 @@ import com.intellij.java.language.JavaLanguage; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.language.Language; import consulo.language.impl.psi.LightElement; import consulo.language.psi.PsiElementVisitor; import consulo.language.psi.PsiManager; import consulo.language.util.IncorrectOperationException; import consulo.util.collection.ArrayUtil; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import java.util.HashSet; @@ -42,7 +41,7 @@ public LightModifierList(PsiManager manager) { this(manager, JavaLanguage.INSTANCE); } - public LightModifierList(PsiManager manager, final Language language, String... modifiers) { + public LightModifierList(PsiManager manager, Language language, String... modifiers) { super(manager, language); myModifiers = new HashSet<>(Set.of(modifiers)); } @@ -67,6 +66,7 @@ public void clearModifiers() { } @Override + @RequiredReadAction public boolean hasModifierProperty(@Nonnull String name) { return myModifiers.contains(name); } @@ -106,20 +106,21 @@ public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { @Override @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { throw new IncorrectOperationException(); } @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitModifierList(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitModifierList(this); } else { visitor.visitElement(this); } } + @Override public String toString() { return "PsiModifierList"; } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java index fbc8714976..2f11960bb6 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeElement.java @@ -18,13 +18,12 @@ import com.intellij.java.language.JavaLanguage; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.language.impl.psi.LightElement; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiElementVisitor; import consulo.language.psi.PsiManager; -import consulo.language.impl.psi.LightElement; import consulo.language.util.IncorrectOperationException; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; /** @@ -39,19 +38,22 @@ public LightTypeElement(PsiManager manager, PsiType type) { myType = type; } + @Override + @RequiredReadAction public String toString() { return "PsiTypeElement:" + getText(); } @Override + @RequiredReadAction public String getText() { return myType.getPresentableText(); } @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeElement(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitTypeElement(this); } else { visitor.visitElement(this); @@ -86,13 +88,13 @@ public PsiAnnotation[] getAnnotations() { } @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { return myType.findAnnotation(qualifiedName); } @Override @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { throw new IncorrectOperationException(); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java index 68edd18731..9a312292dc 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameter.java @@ -19,13 +19,13 @@ import com.intellij.java.language.psi.PsiAnnotation; import com.intellij.java.language.psi.PsiTypeParameter; import com.intellij.java.language.psi.PsiTypeParameterListOwner; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiElementVisitor; import jakarta.annotation.Nonnull; -import org.jetbrains.annotations.NonNls; public class LightTypeParameter extends LightClass implements PsiTypeParameter { - public LightTypeParameter(final PsiTypeParameter delegate) { + public LightTypeParameter(PsiTypeParameter delegate) { super(delegate); } @@ -42,9 +42,9 @@ public PsiElement copy() { } @Override - public void accept(@Nonnull final PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); + public void accept(@Nonnull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor elementVisitor) { + elementVisitor.visitTypeParameter(this); } else { super.accept(visitor); @@ -74,13 +74,13 @@ public PsiAnnotation[] getApplicableAnnotations() { } @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls final String qualifiedName) { + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { return getDelegate().findAnnotation(qualifiedName); } @Nonnull @Override - public PsiAnnotation addAnnotation(@Nonnull @NonNls final String qualifiedName) { + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { return getDelegate().addAnnotation(qualifiedName); } @@ -89,6 +89,7 @@ public boolean useDelegateToSubstitute() { } @Override + @RequiredReadAction public String toString() { return "PsiTypeParameter:" + getName(); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java index a9423f9f18..6dd9caf5fc 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/light/LightTypeParameterBuilder.java @@ -10,7 +10,6 @@ import jakarta.annotation.Nullable; public class LightTypeParameterBuilder extends LightPsiClassBuilder implements PsiTypeParameter { - private final PsiTypeParameterListOwner myOwner; private final int myIndex; @@ -22,8 +21,8 @@ public LightTypeParameterBuilder(@Nonnull String name, PsiTypeParameterListOwner @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitTypeParameter(this); } else { visitor.visitElement(this); diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java index 5f79e24802..eef09d22d8 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiModifierListImpl.java @@ -8,6 +8,7 @@ import com.intellij.java.language.impl.psi.impl.java.stubs.PsiModifierListStub; import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.augment.PsiAugmentProvider; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import consulo.language.ast.IElementType; import consulo.language.impl.ast.CompositeElement; @@ -61,15 +62,16 @@ public class PsiModifierListImpl extends JavaStubPsiElement private volatile ModifierCache myModifierCache; - public PsiModifierListImpl(final PsiModifierListStub stub) { + public PsiModifierListImpl(PsiModifierListStub stub) { super(stub, JavaStubElementTypes.MODIFIER_LIST); } - public PsiModifierListImpl(final ASTNode node) { + public PsiModifierListImpl(ASTNode node) { super(node); } @Override + @RequiredReadAction public boolean hasModifierProperty(@Nonnull String name) { ModifierCache modifierCache = myModifierCache; if (modifierCache == null || !modifierCache.isUpToDate()) { @@ -78,6 +80,7 @@ public boolean hasModifierProperty(@Nonnull String name) { return modifierCache.modifiers.contains(name); } + @RequiredReadAction private ModifierCache calcModifiers() { Set modifiers = calcExplicitModifiers(); modifiers.addAll(calcImplicitModifiers(modifiers)); @@ -88,6 +91,7 @@ private ModifierCache calcModifiers() { return new ModifierCache(file, PsiAugmentProvider.transformModifierProperties(this, file.getProject(), modifiers)); } + @RequiredReadAction private Set calcExplicitModifiers() { Set explicitModifiers = new HashSet<>(); PsiModifierListStub stub = getGreenStub(); @@ -112,12 +116,12 @@ private Set calcExplicitModifiers() { private Set calcImplicitModifiers(Set explicitModifiers) { Set implicitModifiers = new HashSet<>(); PsiElement parent = getParent(); - if (parent instanceof PsiClass) { - PsiElement grandParent = parent.getContext(); - if (grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + if (parent instanceof PsiClass psiClass) { + PsiElement grandParent = psiClass.getContext(); + if (grandParent instanceof PsiClass outerClass && outerClass.isInterface()) { Collections.addAll(implicitModifiers, PUBLIC, STATIC); } - if (((PsiClass)parent).isInterface()) { + if (psiClass.isInterface()) { implicitModifiers.add(ABSTRACT); // nested or local interface is implicitly static @@ -125,22 +129,21 @@ private Set calcImplicitModifiers(Set explicitModifiers) { implicitModifiers.add(STATIC); } } - if (((PsiClass)parent).isRecord()) { + if (psiClass.isRecord()) { if (!(grandParent instanceof PsiFile)) { implicitModifiers.add(STATIC); } implicitModifiers.add(FINAL); } - if (((PsiClass)parent).isEnum()) { + if (psiClass.isEnum()) { if (!(grandParent instanceof PsiFile)) { implicitModifiers.add(STATIC); } - List fields = parent instanceof PsiExtensibleClass ? ((PsiExtensibleClass)parent).getOwnFields() - : Arrays.asList(((PsiClass)parent).getFields()); - boolean hasSubClass = ContainerUtil.find( - fields, - field -> field instanceof PsiEnumConstant && ((PsiEnumConstant)field).getInitializingClass() != null - ) != null; + List fields = parent instanceof PsiExtensibleClass extensibleClass + ? extensibleClass.getOwnFields() + : Arrays.asList(psiClass.getFields()); + boolean hasSubClass = + ContainerUtil.find(fields, field -> field instanceof PsiEnumConstant eс && eс.getInitializingClass() != null) != null; if (hasSubClass) { implicitModifiers.add(SEALED); } @@ -148,18 +151,19 @@ private Set calcImplicitModifiers(Set explicitModifiers) { implicitModifiers.add(FINAL); } - List methods = parent instanceof PsiExtensibleClass ? ((PsiExtensibleClass)parent).getOwnMethods() - : Arrays.asList(((PsiClass)parent).getMethods()); + List methods = parent instanceof PsiExtensibleClass extensibleClass + ? extensibleClass.getOwnMethods() + : Arrays.asList(psiClass.getMethods()); for (PsiMethod method : methods) { - if (method.hasModifierProperty(ABSTRACT)) { + if (method.isAbstract()) { implicitModifiers.add(ABSTRACT); break; } } } } - else if (parent instanceof PsiMethod) { - PsiClass aClass = ((PsiMethod)parent).getContainingClass(); + else if (parent instanceof PsiMethod method) { + PsiClass aClass = method.getContainingClass(); if (aClass != null && aClass.isInterface()) { if (!explicitModifiers.contains(PRIVATE)) { implicitModifiers.add(PUBLIC); @@ -168,27 +172,27 @@ else if (parent instanceof PsiMethod) { } } } - else if (aClass != null && aClass.isEnum() && ((PsiMethod)parent).isConstructor()) { + else if (aClass != null && aClass.isEnum() && method.isConstructor()) { implicitModifiers.add(PRIVATE); } } else if (parent instanceof PsiRecordComponent) { implicitModifiers.add(FINAL); } - else if (parent instanceof PsiField) { + else if (parent instanceof PsiField field) { if (parent instanceof PsiEnumConstant) { Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL); } else { - PsiClass aClass = ((PsiField)parent).getContainingClass(); + PsiClass aClass = field.getContainingClass(); if (aClass != null && aClass.isInterface()) { Collections.addAll(implicitModifiers, PUBLIC, STATIC, FINAL); } } } - else if (parent instanceof PsiParameter && - parent.getParent() instanceof PsiCatchSection && - ((PsiParameter)parent).getType() instanceof PsiDisjunctionType) { + else if (parent instanceof PsiParameter parameter + && parameter.getParent() instanceof PsiCatchSection + && parameter.getType() instanceof PsiDisjunctionType) { Collections.addAll(implicitModifiers, FINAL); } else if (parent instanceof PsiResourceVariable) { @@ -198,18 +202,20 @@ else if (parent instanceof PsiResourceVariable) { } @Override + @RequiredReadAction public boolean hasExplicitModifier(@Nonnull String name) { PsiModifierListStub stub = getGreenStub(); if (stub != null) { return BitUtil.isSet(stub.getModifiersMask(), ModifierFlags.NAME_TO_MODIFIER_FLAG_MAP.getInt(name)); } - final CompositeElement tree = (CompositeElement)getNode(); - final IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name); + CompositeElement tree = (CompositeElement)getNode(); + IElementType type = NAME_TO_KEYWORD_TYPE_MAP.get(name); return type != null && tree.findChildByType(type) != null; } @Override + @RequiredReadAction public void setModifierProperty(@Nonnull String name, boolean value) throws IncorrectOperationException { checkSetModifierProperty(name, value); @@ -220,8 +226,7 @@ public void setModifierProperty(@Nonnull String name, boolean value) throws Inco // There is a possible case that parameters list occupies more than one line and its elements are aligned. Modifiers list change // changes horizontal position of parameters list start, hence, we need to reformat them in order to preserve alignment. - if (parent instanceof PsiMethod) { - PsiMethod method = (PsiMethod)parent; + if (parent instanceof PsiMethod method) { ASTNode node = method.getParameterList().getNode(); if (node != null) { // could be a compact constructor parameter list CodeEditUtil.markToReformat(node, true); @@ -259,22 +264,22 @@ public void setModifierProperty(@Nonnull String name, boolean value) throws Inco } } - if (parent instanceof PsiField && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + if (parent instanceof PsiField && grandParent instanceof PsiClass psiClass && psiClass.isInterface()) { if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.STATIC_KEYWORD || type == JavaTokenType.FINAL_KEYWORD) { return; } } - else if (parent instanceof PsiMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + else if (parent instanceof PsiMethod && grandParent instanceof PsiClass psiClass && psiClass.isInterface()) { if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) { return; } } - else if (parent instanceof PsiClass && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) { + else if (parent instanceof PsiClass && grandParent instanceof PsiClass outerClass && outerClass.isInterface()) { if (type == JavaTokenType.PUBLIC_KEYWORD) { return; } } - else if (parent instanceof PsiAnnotationMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isAnnotationType()) { + else if (parent instanceof PsiAnnotationMethod && grandParent instanceof PsiClass psiClass && psiClass.isAnnotationType()) { if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) { return; } @@ -310,14 +315,18 @@ public PsiAnnotation[] getAnnotations() { return ArrayUtil.mergeArrayAndCollection(own, ext, PsiAnnotation.ARRAY_FACTORY); } - @Override @Nonnull + @Override + @RequiredReadAction public PsiAnnotation[] getApplicableAnnotations() { PsiAnnotation.TargetType[] targets = AnnotationTargetUtil.getTargetsForLocation(this); - List filtered = ContainerUtil.findAll(getAnnotations(), annotation -> { - PsiAnnotation.TargetType target = AnnotationTargetUtil.findAnnotationTarget(annotation, targets); - return target != null && target != PsiAnnotation.TargetType.UNKNOWN; - }); + List filtered = ContainerUtil.findAll( + getAnnotations(), + annotation -> { + PsiAnnotation.TargetType target = AnnotationTargetUtil.findAnnotationTarget(annotation, targets); + return target != null && target != PsiAnnotation.TargetType.UNKNOWN; + } + ); return filtered.toArray(PsiAnnotation.EMPTY_ARRAY); } @@ -338,8 +347,8 @@ public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitModifierList(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitModifierList(this); } else { visitor.visitElement(this); @@ -347,6 +356,7 @@ public void accept(@Nonnull PsiElementVisitor visitor) { } @Override + @RequiredReadAction public String toString() { return "PsiModifierList:" + getText(); } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java index 945e3f2848..9b8937708d 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/PsiTypeElementImpl.java @@ -26,6 +26,8 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.augment.PsiAugmentProvider; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.application.util.CachedValueProvider; import consulo.application.util.RecursionGuard; import consulo.application.util.RecursionManager; @@ -64,16 +66,17 @@ public PsiTypeElementImpl() { @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeElement(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitTypeElement(this); } else { visitor.visitElement(this); } } - @Override @Nonnull + @Override + @RequiredReadAction public PsiType getType() { return LanguageCachedValueUtil.getCachedValue( this, @@ -85,6 +88,7 @@ public PsiType getType() { } @Nonnull + @RequiredReadAction private PsiType calculateType() { PsiType inferredType = PsiAugmentProvider.getInferredType(this); if (inferredType != null) { @@ -98,47 +102,41 @@ private PsiType calculateType() { PsiElement parent = getParent(); PsiElement firstChild = getFirstChild(); - if (firstChild == null && parent instanceof PsiUnnamedPattern) { - type = JavaPsiPatternUtil.getDeconstructedImplicitPatternType((PsiPattern)parent); + if (firstChild == null && parent instanceof PsiUnnamedPattern unnamedPattern) { + type = JavaPsiPatternUtil.getDeconstructedImplicitPatternType(unnamedPattern); } for (PsiElement child = firstChild; child != null; child = child.getNextSibling()) { if (child instanceof PsiComment || child instanceof PsiWhiteSpace) { continue; } - if (child instanceof PsiAnnotation) { - annotations.add((PsiAnnotation)child); + if (child instanceof PsiAnnotation annotation) { + annotations.add(annotation); } - else if (child instanceof PsiTypeElement) { + else if (child instanceof PsiTypeElement typeElem) { assert type == null : this; if (child instanceof PsiDiamondTypeElementImpl) { type = new PsiDiamondTypeImpl(getManager(), this); break; } else { - type = ((PsiTypeElement)child).getType(); + type = typeElem.getType(); } } else if (PsiUtil.isJavaToken(child, ElementType.PRIMITIVE_TYPE_BIT_SET)) { assert type == null : this; String text = child.getText(); - type = - annotations.isEmpty() ? PsiJavaParserFacadeImpl.getPrimitiveType(text) : new PsiPrimitiveType( - text, - createProvider(annotations) - ); + type = annotations.isEmpty() + ? PsiJavaParserFacadeImpl.getPrimitiveType(text) + : new PsiPrimitiveType(text, createProvider(annotations)); } else if (PsiUtil.isJavaToken(child, JavaTokenType.VAR_KEYWORD)) { assert type == null : this; type = inferVarType(parent); } - else if (child instanceof PsiJavaCodeReferenceElement) { + else if (child instanceof PsiJavaCodeReferenceElement codeRefElem) { assert type == null : this; - type = new PsiClassReferenceType( - getReferenceComputable((PsiJavaCodeReferenceElement)child), - null, - createProvider(annotations) - ); + type = new PsiClassReferenceType(getReferenceComputable(codeRefElem), null, createProvider(annotations)); } else if (PsiUtil.isJavaToken(child, JavaTokenType.LBRACKET)) { assert type != null : this; @@ -156,11 +154,11 @@ else if (PsiUtil.isJavaToken(child, JavaTokenType.ELLIPSIS)) { assert type == null : this; PsiElement boundKind = PsiTreeUtil.skipWhitespacesAndCommentsForward(child); PsiElement boundType = PsiTreeUtil.skipWhitespacesAndCommentsForward(boundKind); - if (PsiUtil.isJavaToken(boundKind, JavaTokenType.EXTENDS_KEYWORD) && boundType instanceof PsiTypeElement) { - type = PsiWildcardType.createExtends(getManager(), ((PsiTypeElement)boundType).getType()); + if (PsiUtil.isJavaToken(boundKind, JavaTokenType.EXTENDS_KEYWORD) && boundType instanceof PsiTypeElement typeElem) { + type = PsiWildcardType.createExtends(getManager(), typeElem.getType()); } - else if (PsiUtil.isJavaToken(boundKind, JavaTokenType.SUPER_KEYWORD) && boundType instanceof PsiTypeElement) { - type = PsiWildcardType.createSuper(getManager(), ((PsiTypeElement)boundType).getType()); + else if (PsiUtil.isJavaToken(boundKind, JavaTokenType.SUPER_KEYWORD) && boundType instanceof PsiTypeElement typeElem) { + type = PsiWildcardType.createSuper(getManager(), typeElem.getType()); } else { type = PsiWildcardType.createUnbounded(getManager()); @@ -168,10 +166,8 @@ else if (PsiUtil.isJavaToken(boundKind, JavaTokenType.SUPER_KEYWORD) && boundTyp type = type.annotate(createProvider(annotations)); break; } - else { - if (child instanceof ASTNode) { - ((ASTNode)child).getElementType(); - } + else if (child instanceof ASTNode childNode) { + childNode.getElementType(); } if (PsiUtil.isJavaToken(child, JavaTokenType.AND)) { @@ -197,8 +193,8 @@ else if (PsiUtil.isJavaToken(boundKind, JavaTokenType.SUPER_KEYWORD) && boundTyp type = createArray(type, arrayComponentAnnotations, ellipsis); } - if (parent instanceof PsiModifierListOwner) { - type = JavaSharedImplUtil.applyAnnotations(type, ((PsiModifierListOwner)parent).getModifierList()); + if (parent instanceof PsiModifierListOwner modifierListOwner) { + type = JavaSharedImplUtil.applyAnnotations(type, modifierListOwner.getModifierList()); } return type; @@ -214,15 +210,15 @@ private static PsiType createArray(PsiType elementType, List expression.getType()); + PsiType type = RecursionManager.doPreventingRecursion(expression, true, expression::getType); if (stamp.mayCacheNow()) { return type == null ? null : JavaVarTypeUtil.getUpwardProjection(type); } @@ -282,7 +277,9 @@ private static ClassReferencePointer getReferenceComputable(@Nonnull PsiJavaCode private static PsiTypeElement getRootTypeElement(@Nonnull PsiJavaCodeReferenceElement ref) { PsiElement root = SyntaxTraverser.psiApi() .parents(ref.getParent()) - .takeWhile(it -> it instanceof PsiTypeElement || it instanceof PsiReferenceParameterList || it instanceof PsiJavaCodeReferenceElement) + .takeWhile( + it -> it instanceof PsiTypeElement || it instanceof PsiReferenceParameterList || it instanceof PsiJavaCodeReferenceElement + ) .last(); return ObjectUtil.tryCast(root, PsiTypeElement.class); } @@ -303,8 +300,8 @@ PsiJavaCodeReferenceElement retrieveReference() { PsiJavaCodeReferenceElement result = myCache.get(); if (result == null) { PsiType type = calcTypeByParent(); - if (type instanceof PsiClassReferenceType) { - result = findReferenceByIndex((PsiClassReferenceType)type); + if (type instanceof PsiClassReferenceType classRefType) { + result = findReferenceByIndex(classRefType); } myCache = new WeakReference<>(result); } @@ -323,11 +320,9 @@ private PsiType calcTypeByParent() { return null; } - PsiType type = parent instanceof PsiMethod ? ((PsiMethod)parent).getReturnType() : ((PsiVariable)parent).getType(); - if (type instanceof PsiArrayType) { //also, for c-style array, e.g. String args[] - return type.getDeepComponentType(); - } - return type; + PsiType type = parent instanceof PsiMethod method ? method.getReturnType() : ((PsiVariable)parent).getType(); + //also, for c-style array, e.g. String args[] + return type instanceof PsiArrayType arrayType ? arrayType.getDeepComponentType() : type; } @Override @@ -337,13 +332,13 @@ PsiJavaCodeReferenceElement retrieveNonNullReference() { PsiJavaCodeReferenceElement result = retrieveReference(); if (result == null) { PsiType type = calcTypeByParent(); - if (!(type instanceof PsiClassReferenceType)) { + if (!(type instanceof PsiClassReferenceType classRefType)) { PsiUtilCore.ensureValid(parent); throw new IllegalStateException( "No reference type for " + parent.getClass() + "; type: " + (type != null ? type.getClass() : "null") ); } - result = findReferenceByIndex((PsiClassReferenceType)type); + result = findReferenceByIndex(classRefType); if (result == null) { PsiUtilCore.ensureValid(parent); throw new RuntimeExceptionWithAttachments( @@ -356,6 +351,7 @@ PsiJavaCodeReferenceElement retrieveNonNullReference() { } @Override + @RequiredReadAction public String toString() { String msg = "Type element reference of " + parent.getClass() + " #" + parent.getClass().getSimpleName() + ", index=" + index; @@ -375,9 +371,10 @@ private static TypeAnnotationProvider createProvider(@Nonnull List collectTypes() { List typeElements = PsiTreeUtil.getChildrenOfTypeAsList(this, PsiTypeElement.class); - return ContainerUtil.map(typeElements, typeElement -> typeElement.getType()); + return ContainerUtil.map(typeElements, PsiTypeElement::getType); } @Override @@ -412,15 +409,17 @@ public boolean processDeclarations( return true; } - @Override @Nonnull + @Override + @RequiredReadAction public PsiAnnotation[] getAnnotations() { PsiAnnotation[] annotations = PsiTreeUtil.getChildrenOfType(this, PsiAnnotation.class); return annotations != null ? annotations : PsiAnnotation.EMPTY_ARRAY; } - @Override @Nonnull + @Override + @RequiredReadAction public PsiAnnotation[] getApplicableAnnotations() { return getType().getAnnotations(); } @@ -430,8 +429,9 @@ public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { return PsiImplUtil.findAnnotation(this, qualifiedName); } - @Override @Nonnull + @Override + @RequiredWriteAction public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { PsiAnnotation annotation = JavaPsiFacade.getElementFactory(getProject()).createAnnotationFromText('@' + qualifiedName, this); PsiElement firstChild = getFirstChild(); @@ -448,14 +448,14 @@ public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { } } PsiElement parent = getParent(); - while (parent instanceof PsiTypeElement && ((PsiTypeElement)parent).getType() instanceof PsiArrayType) { - parent = parent.getParent(); + while (parent instanceof PsiTypeElement typeElem && typeElem.getType() instanceof PsiArrayType) { + parent = typeElem.getParent(); } - if (parent instanceof PsiModifierListOwner) { - PsiModifierList modifierList = ((PsiModifierListOwner)parent).getModifierList(); + if (parent instanceof PsiModifierListOwner modifierListOwner) { + PsiModifierList modifierList = modifierListOwner.getModifierList(); if (modifierList != null) { PsiTypeParameterList list = - parent instanceof PsiTypeParameterListOwner ? ((PsiTypeParameterListOwner)parent).getTypeParameterList() : null; + parent instanceof PsiTypeParameterListOwner typeParamListOwner ? typeParamListOwner.getTypeParameterList() : null; if (list == null || list.textMatches("")) { return (PsiAnnotation)modifierList.add(annotation); } @@ -465,20 +465,22 @@ public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { } @Override + @RequiredWriteAction public PsiElement replace(@Nonnull PsiElement newElement) throws IncorrectOperationException { // neighbouring type annotations are logical part of this type element and should be dropped //if replacement is `var`, annotations should be left as they are not inferred from the right side of the assignment - if (!(newElement instanceof PsiTypeElement) || !((PsiTypeElement)newElement).isInferredType()) { + if (!(newElement instanceof PsiTypeElement typeElem) || !typeElem.isInferredType()) { PsiImplUtil.markTypeAnnotations(this); } PsiElement result = super.replace(newElement); - if (result instanceof PsiTypeElement) { - PsiImplUtil.deleteTypeAnnotations((PsiTypeElement)result); + if (result instanceof PsiTypeElement typeElem) { + PsiImplUtil.deleteTypeAnnotations(typeElem); } return result; } @Override + @RequiredReadAction public boolean acceptsAnnotations() { if (isInferredType()) { return false; diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/graphInference/InferenceVariable.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/graphInference/InferenceVariable.java index 8d20a64ff7..7562181f78 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/graphInference/InferenceVariable.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/resolve/graphInference/InferenceVariable.java @@ -20,6 +20,7 @@ import com.intellij.java.language.psi.augment.TypeAnnotationModifier; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiElement; import consulo.language.psi.util.PsiTreeUtil; import jakarta.annotation.Nonnull; @@ -28,7 +29,7 @@ import java.util.*; /** - * User: anna + * @author anna */ public class InferenceVariable extends LightTypeParameter { private final PsiElement myContext; @@ -213,6 +214,7 @@ public boolean useDelegateToSubstitute() { } @Override + @RequiredReadAction public String toString() { return getDelegate().toString(); } @@ -224,6 +226,7 @@ public PsiTypeParameterListOwner getOwner() { @Nullable @Override + @RequiredReadAction public String getName() { return myName; } diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java index 18051238d8..d0f4a2dee4 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiCompositeModifierList.java @@ -13,13 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/* - * @author max - */ package com.intellij.java.language.impl.psi.impl.source.tree.java; import com.intellij.java.language.psi.PsiAnnotation; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.PsiManager; import com.intellij.java.language.psi.PsiModifierList; import com.intellij.java.language.impl.psi.impl.light.LightModifierList; @@ -29,10 +26,13 @@ import java.util.ArrayList; import java.util.List; +/** + * @author max + */ public class PsiCompositeModifierList extends LightModifierList { private final List mySublists; - public PsiCompositeModifierList(final PsiManager manager, List sublists) { + public PsiCompositeModifierList(PsiManager manager, List sublists) { super(manager); mySublists = sublists; } @@ -40,7 +40,7 @@ public PsiCompositeModifierList(final PsiManager manager, List @Override @Nonnull public PsiAnnotation[] getAnnotations() { - List annotations = new ArrayList(); + List annotations = new ArrayList<>(); for (PsiModifierList list : mySublists) { ContainerUtil.addAll(annotations, list.getAnnotations()); } @@ -48,9 +48,9 @@ public PsiAnnotation[] getAnnotations() { } @Override - public PsiAnnotation findAnnotation(@Nonnull final String qualifiedName) { + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { for (PsiModifierList sublist : mySublists) { - final PsiAnnotation annotation = sublist.findAnnotation(qualifiedName); + PsiAnnotation annotation = sublist.findAnnotation(qualifiedName); if (annotation != null) { return annotation; } @@ -60,7 +60,8 @@ public PsiAnnotation findAnnotation(@Nonnull final String qualifiedName) { } @Override - public boolean hasModifierProperty(@Nonnull final String name) { + @RequiredReadAction + public boolean hasModifierProperty(@Nonnull String name) { for (PsiModifierList sublist : mySublists) { if (sublist.hasModifierProperty(name)) { return true; @@ -70,7 +71,7 @@ public boolean hasModifierProperty(@Nonnull final String name) { } @Override - public boolean hasExplicitModifier(@Nonnull final String name) { + public boolean hasExplicitModifier(@Nonnull String name) { for (PsiModifierList sublist : mySublists) { if (sublist.hasExplicitModifier(name)) { return true; diff --git a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java index 84ec65a0fb..31ebe67d50 100644 --- a/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java +++ b/java-language-impl/src/main/java/com/intellij/java/language/impl/psi/impl/source/tree/java/PsiTypeParameterImpl.java @@ -27,6 +27,8 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.javadoc.PsiDocComment; import com.intellij.java.language.psi.util.PsiUtil; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.content.scope.SearchScope; import consulo.language.ast.ASTNode; import consulo.language.psi.PsiElement; @@ -41,8 +43,6 @@ import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; import consulo.util.lang.Pair; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import java.util.Collection; @@ -59,11 +59,11 @@ public PsiManager getManager() { } }; - public PsiTypeParameterImpl(final PsiTypeParameterStub stub) { + public PsiTypeParameterImpl(PsiTypeParameterStub stub) { super(stub, JavaStubElementTypes.TYPE_PARAMETER); } - public PsiTypeParameterImpl(final ASTNode node) { + public PsiTypeParameterImpl(ASTNode node) { super(node); } @@ -166,25 +166,22 @@ public boolean isInheritor(@Nonnull PsiClass baseClass, boolean checkDeep) { @Override public PsiTypeParameterListOwner getOwner() { - final PsiElement parent = getParent(); + PsiElement parent = getParent(); if (parent == null) { throw new PsiInvalidElementAccessException(this); } - final PsiElement parentParent = parent.getParent(); - if (!(parentParent instanceof PsiTypeParameterListOwner)) { - // Might be an error element; - return PsiTreeUtil.getParentOfType(this, PsiTypeParameterListOwner.class); - } - return (PsiTypeParameterListOwner)parentParent; + return parent.getParent() instanceof PsiTypeParameterListOwner owner ? owner + : PsiTreeUtil.getParentOfType(this, PsiTypeParameterListOwner.class); // Might be an error element } @Override + @RequiredReadAction public int getIndex() { - final PsiTypeParameterStub stub = getStub(); + PsiTypeParameterStub stub = getStub(); if (stub != null) { - final PsiTypeParameterListStub parentStub = (PsiTypeParameterListStub)stub.getParentStub(); + PsiTypeParameterListStub parentStub = (PsiTypeParameterListStub)stub.getParentStub(); return parentStub.getChildrenStubs().indexOf(stub); } @@ -199,13 +196,15 @@ public int getIndex() { return ret; } - @Override @Nonnull + @Override + @RequiredReadAction public PsiIdentifier getNameIdentifier() { return PsiTreeUtil.getRequiredChildOfType(this, PsiIdentifier.class); } @Override + @RequiredReadAction public boolean processDeclarations( @Nonnull PsiScopeProcessor processor, @Nonnull ResolveState state, @@ -225,8 +224,9 @@ public boolean processDeclarations( } @Override + @RequiredReadAction public String getName() { - final PsiTypeParameterStub stub = getStub(); + PsiTypeParameterStub stub = getStub(); if (stub != null) { return stub.getName(); } @@ -235,6 +235,7 @@ public String getName() { } @Override + @RequiredWriteAction public PsiElement setName(@Nonnull String name) throws IncorrectOperationException { PsiImplUtil.setName(getNameIdentifier(), name); return this; @@ -320,6 +321,7 @@ public PsiClass getSuperClass() { return PsiClassImplUtil.getSuperClass(this); } + @Nonnull @Override public PsiClass[] getInterfaces() { return PsiClassImplUtil.getInterfaces(this); @@ -370,25 +372,27 @@ public PsiJavaToken getRBrace() { @Override public void accept(@Nonnull PsiElementVisitor visitor) { - if (visitor instanceof JavaElementVisitor) { - ((JavaElementVisitor)visitor).visitTypeParameter(this); + if (visitor instanceof JavaElementVisitor elemVisitor) { + elemVisitor.visitTypeParameter(this); } else { visitor.visitElement(this); } } - @NonNls + @Override + @RequiredReadAction public String toString() { return "PsiTypeParameter:" + getName(); } + @Override public PsiMetaData getMetaData() { return MetaDataService.getInstance().getMeta(this); } @Override - public boolean isEquivalentTo(final PsiElement another) { + public boolean isEquivalentTo(PsiElement another) { return PsiClassImplUtil.isClassEquivalentTo(this, another); } @@ -405,13 +409,13 @@ public PsiAnnotation[] getAnnotations() { } @Override - public PsiAnnotation findAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation findAnnotation(@Nonnull String qualifiedName) { return PsiImplUtil.findAnnotation(this, qualifiedName); } @Override @Nonnull - public PsiAnnotation addAnnotation(@Nonnull @NonNls String qualifiedName) { + public PsiAnnotation addAnnotation(@Nonnull String qualifiedName) { throw new IncorrectOperationException(); }