From 12f94449979dc26acf3b2a1f698ee0abdf8218de Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 29 Jul 2026 23:51:41 +0300 Subject: [PATCH] Adding missing @Override annotations (part 5). Adding RRA/RWA/RUI annotations. Some localization and refactoring. --- .../aop/psi/PsiAdviceExecutionExpression.java | 35 ++--- .../aop/psi/PsiAnnotatedTypePattern.java | 49 ++++--- .../intellij/aop/psi/PsiArgsExpression.java | 8 +- .../aop/psi/PsiAtAnnotationExpression.java | 50 +++---- .../intellij/aop/psi/PsiAtArgsExpression.java | 34 ++--- .../aop/psi/PsiAtTargetExpression.java | 50 ++++--- .../intellij/aop/psi/PsiAtThisExpression.java | 50 ++++--- .../aop/psi/PsiAtWithinExpression.java | 52 ++++--- .../intellij/aop/psi/PsiCallExpression.java | 25 ++-- .../psi/PsiControlFlowPointcutExpression.java | 35 ++--- .../aop/psi/PsiExecutionExpression.java | 25 ++-- .../aop/psi/PsiHandlerPointcutExpression.java | 41 +++--- .../aop/psi/PsiIfPointcutExpression.java | 42 +++--- .../PsiInitializationPointcutExpression.java | 29 ++-- .../aop/psi/PsiMonitorPointcutExpression.java | 35 ++--- .../aop/psi/PsiPointcutExpression.java | 9 +- .../psi/PsiPointcutReferenceExpression.java | 14 +- .../aop/psi/PsiPrimitiveTypePattern.java | 24 ++-- .../PsiStaticInitializationExpression.java | 41 +++--- .../intellij/aop/psi/PsiTargetExpression.java | 10 +- .../intellij/aop/psi/PsiThisExpression.java | 7 +- .../psi/PsiWithinCodePointcutExpression.java | 24 ++-- .../intellij/aop/psi/PsiWithinExpression.java | 56 ++++---- .../intellij/aop/psi/PointcutAcceptTest.java | 1 + .../intellij/aop/psi/PsiTypePatternsTest.java | 11 +- .../java/ex/facet/RemoteRepositoryInfo.java | 9 +- .../spring/impl/SpringManagerImpl.java | 21 ++- .../spring/impl/ide/PNamespaceDescriptor.java | 43 +++--- .../ProxyFactoryBeanTypeResolver.java | 22 +-- .../converters/PatternFileReferenceSet.java | 33 ++--- .../converters/PropertyKeyConverter.java | 20 ++- .../model/converters/PsiMethodConverter.java | 41 +++--- .../ReplacedMethodBeanConverter.java | 13 +- .../converters/ResourceResolverUtils.java | 127 +++++++++--------- .../ReplacedMethodsInspection.java | 2 +- .../model/properties/PropertyReference.java | 62 +++++---- .../properties/PropertyReferenceSet.java | 82 +++++------ .../model/values/PropertyValueConverter.java | 10 +- .../ide/model/values/PropsValueConverter.java | 12 +- .../PlaceholderPropertiesConverter.java | 17 +-- .../converters/ResourceValueConverter.java | 50 ++++--- .../ide/model/xml/QualifierAttribute.java | 13 +- .../xml/aop/PointcutExpressionConverter.java | 11 +- .../impl/ide/model/xml/aop/PointcutType.java | 17 ++- .../aop/psi/PsiBeanPointcutExpression.java | 71 +++++----- .../model/beans/PNamespaceRefValueImpl.java | 61 +++++---- .../impl/model/beans/PNamespaceValueImpl.java | 14 +- .../impl/model/beans/ReplacedMethodImpl.java | 19 +-- .../beans/ResolvedConstructorArgsImpl.java | 52 ++++--- .../context/PropertyPlaceholderImpl.java | 10 +- .../spring/impl/model/jee/RemoteSlsbImpl.java | 10 +- 51 files changed, 859 insertions(+), 740 deletions(-) diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAdviceExecutionExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAdviceExecutionExpression.java index 265eaa45..2632b9a3 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAdviceExecutionExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAdviceExecutionExpression.java @@ -8,29 +8,32 @@ import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.Collections; /** * @author peter */ -public class PsiAdviceExecutionExpression extends AopElementBase implements PsiPointcutExpression{ - public PsiAdviceExecutionExpression(@Nonnull ASTNode node) { - super(node); - } +public class PsiAdviceExecutionExpression extends AopElementBase implements PsiPointcutExpression { + public PsiAdviceExecutionExpression(@Nonnull ASTNode node) { + super(node); + } - @Override - public String toString() { - return "PsiAdviceExecutionExpression"; - } + @Override + public String toString() { + return "PsiAdviceExecutionExpression"; + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } - @Nonnull - public Collection getPatterns() { - return Collections.emptyList(); - } + @Nonnull + @Override + public Collection getPatterns() { + return Collections.emptyList(); + } } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAnnotatedTypePattern.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAnnotatedTypePattern.java index 60871f07..c50607aa 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAnnotatedTypePattern.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAnnotatedTypePattern.java @@ -4,9 +4,9 @@ package com.intellij.aop.psi; import com.intellij.java.language.psi.*; -import consulo.language.psi.PsiElement; - +import consulo.annotation.access.RequiredReadAction; import jakarta.annotation.Nonnull; + import java.util.HashSet; import java.util.Set; @@ -24,39 +24,42 @@ public AopPsiTypePattern getAnnotationPattern() { return myAnnotationPattern; } + @Override + @RequiredReadAction public boolean accepts(@Nonnull PsiType type) { - if (type instanceof PsiClassType) { - PsiClass psiClass = ((PsiClassType)type).resolve(); + if (type instanceof PsiClassType classType) { + PsiClass psiClass = classType.resolve(); if (psiClass != null && acceptsAnnotationPattern(psiClass, myAnnotationPattern, false)) return true; } return false; } - public static boolean acceptsAnnotationPattern(@Nonnull PsiModifierListOwner owner, AopPsiTypePattern annoPattern, boolean shoulBeInherited) { - return acceptsAnnotationPattern(owner, annoPattern, shoulBeInherited, new HashSet()); + @RequiredReadAction + public static boolean acceptsAnnotationPattern(@Nonnull PsiModifierListOwner owner, AopPsiTypePattern annoPattern, boolean shouldBeInherited) { + return acceptsAnnotationPattern(owner, annoPattern, shouldBeInherited, new HashSet<>()); } - private static boolean acceptsAnnotationPattern(PsiModifierListOwner owner, AopPsiTypePattern annoPattern, - boolean shoulBeInherited, - Set visited) { + @RequiredReadAction + private static boolean acceptsAnnotationPattern( + PsiModifierListOwner owner, + AopPsiTypePattern annoPattern, + boolean shouldBeInherited, + Set visited + ) { visited.add(owner); - if (annoPattern instanceof NotPattern) { - return !acceptsAnnotationPattern(owner, ((NotPattern)annoPattern).getInnerPattern(), shoulBeInherited); + if (annoPattern instanceof NotPattern notPattern) { + return !acceptsAnnotationPattern(owner, notPattern.getInnerPattern(), shouldBeInherited); } PsiModifierList modifierList = owner.getModifierList(); if (modifierList != null) { for (PsiAnnotation annotation : modifierList.getAnnotations()) { PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement(); - if (element != null) { - PsiElement psiElement = element.resolve(); - if (psiElement instanceof PsiClass) { - PsiClass annoClass = (PsiClass)psiElement; - if (annoPattern.accepts(JavaPsiFacade.getInstance(psiElement.getProject()).getElementFactory().createType(annoClass))) { - PsiModifierList list = annoClass.getModifierList(); - return !shoulBeInherited || list != null && list.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_INHERITED) != null; - } - } + if (element != null + && element.resolve() instanceof PsiClass annoClass + && annoPattern.accepts(JavaPsiFacade.getInstance(annoClass.getProject()).getElementFactory().createType(annoClass))) { + PsiModifierList list = annoClass.getModifierList(); + return !shouldBeInherited || list != null && list.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_INHERITED) != null; } String qualifiedName = annotation.getQualifiedName(); if (qualifiedName != null && annoPattern.accepts(qualifiedName)) { @@ -64,8 +67,8 @@ private static boolean acceptsAnnotationPattern(PsiModifierListOwner owner, AopP } } } - if (owner instanceof PsiClass) { - PsiClass superClass = ((PsiClass) owner).getSuperClass(); + if (owner instanceof PsiClass psiClass) { + PsiClass superClass = psiClass.getSuperClass(); return superClass != null && !visited.contains(superClass) && acceptsAnnotationPattern(superClass, annoPattern, true); } @@ -73,6 +76,8 @@ private static boolean acceptsAnnotationPattern(PsiModifierListOwner owner, AopP } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree canBeAssignableFrom(@Nonnull PsiType type) { return PointcutMatchDegree.valueOf(accepts(type)); } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiArgsExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiArgsExpression.java index 752fd0ab..851a2b27 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiArgsExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiArgsExpression.java @@ -1,11 +1,11 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.impl.psi.impl.PsiElementFactoryImpl; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import consulo.util.lang.Comparing; @@ -19,6 +19,7 @@ */ public class PsiArgsExpression extends AopElementBase implements PsiPointcutExpression{ private static final TypeArgumentMatcher ARGS_MATCHER = new TypeArgumentMatcher() { + @Override public PointcutMatchDegree fun(PsiType actualType, AopReferenceTarget target) { if (super.fun(actualType, target) == PointcutMatchDegree.TRUE || target.isAssignableFrom(actualType)) { return PointcutMatchDegree.TRUE; @@ -42,16 +43,20 @@ public PsiArgsExpression(@Nonnull ASTNode node) { super(node); } + @Override public String toString() { return "PsiArgsExpression"; } @Nullable + @RequiredReadAction public AopParameterList getParameterList() { return findChildByClass(AopParameterList.class); } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { if (member instanceof PsiMethod) { AopParameterList parameterList = getParameterList(); @@ -61,6 +66,7 @@ public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember mem } @Nonnull + @Override public Collection getPatterns() { return Arrays.asList(AopPsiTypePattern.TRUE); } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtAnnotationExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtAnnotationExpression.java index 0ee9f209..6f2f805a 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtAnnotationExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtAnnotationExpression.java @@ -1,39 +1,43 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; /** * @author peter */ -public class PsiAtAnnotationExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator{ - - public PsiAtAnnotationExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiAtAnnotationExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - AopReferenceHolder pattern = getTypeReference(); - if (pattern == null) return PointcutMatchDegree.FALSE; - - return PointcutMatchDegree.valueOf(member.getModifierList().findAnnotation(context.resolve(pattern).getQualifiedName()) != null); - } - - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.TRUE); - } +public class PsiAtAnnotationExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator { + public PsiAtAnnotationExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiAtAnnotationExpression"; + } + + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + AopReferenceHolder pattern = getTypeReference(); + if (pattern == null) { + return PointcutMatchDegree.FALSE; + } + + return PointcutMatchDegree.valueOf(member.getModifierList().findAnnotation(context.resolve(pattern).getQualifiedName()) != null); + } + + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.TRUE); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtArgsExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtArgsExpression.java index 87daa4ce..3a10cad3 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtArgsExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtArgsExpression.java @@ -1,15 +1,14 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; -import consulo.util.lang.function.PairFunction; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Arrays; import java.util.Collection; import java.util.HashSet; @@ -19,50 +18,53 @@ * @author peter */ public class PsiAtArgsExpression extends AopElementBase implements PsiPointcutExpression, PsiAtPointcutDesignator{ - public PsiAtArgsExpression(@Nonnull ASTNode node) { super(node); } + @Override public String toString() { return "PsiAtArgsExpression"; } @Nullable + @RequiredReadAction public AopParameterList getParameterList() { return findChildByClass(AopParameterList.class); } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - if (!(member instanceof PsiMethod)) return PointcutMatchDegree.FALSE; + if (!(member instanceof PsiMethod method)) return PointcutMatchDegree.FALSE; AopParameterList list = getParameterList(); if (list == null) return PointcutMatchDegree.FALSE; - - - return list.matches(context, ((PsiMethod)member).getParameterList(), new PairFunction() { - public PointcutMatchDegree fun(PsiType actualType, AopReferenceTarget holder) { - return actualType instanceof PsiClassType - ? canHaveAnnotation(((PsiClassType)actualType).resolve(), holder, PointcutMatchDegree.TRUE, PointcutMatchDegree.MAYBE) - : PointcutMatchDegree.FALSE; - } - }); + return list.matches( + context, + method.getParameterList(), + (actualType, holder) -> actualType instanceof PsiClassType classType + ? canHaveAnnotation(classType.resolve(), holder, PointcutMatchDegree.TRUE, PointcutMatchDegree.MAYBE) + : PointcutMatchDegree.FALSE + ); } @Nonnull + @Override public Collection getPatterns() { return Arrays.asList(AopPsiTypePattern.TRUE); } - + @RequiredReadAction public static PointcutMatchDegree canHaveAnnotation(@Nullable PsiClass psiClass, @Nullable AopReferenceHolder holder, PointcutContext context, PointcutMatchDegree maybeTrue, PointcutMatchDegree maybeFalse) { if (holder == null) return PointcutMatchDegree.FALSE; return canHaveAnnotation(psiClass, context.resolve(holder), maybeTrue, maybeFalse); } + @RequiredReadAction public static PointcutMatchDegree canHaveAnnotation(@Nullable PsiClass psiClass, @Nonnull AopReferenceTarget holder, PointcutMatchDegree maybeTrue, PointcutMatchDegree maybeFalse) { if (psiClass == null) return PointcutMatchDegree.FALSE; @@ -84,7 +86,7 @@ public static PointcutMatchDegree canHaveAnnotation(@Nullable PsiClass psiClass, if (psiClass.isInterface()) return maybeFalse; - Set visited = new HashSet(); + Set visited = new HashSet<>(); visited.add(psiClass); while (true) { diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtTargetExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtTargetExpression.java index 4fd98229..7926692f 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtTargetExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtTargetExpression.java @@ -1,36 +1,46 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; /** * @author peter */ -public class PsiAtTargetExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator{ - - public PsiAtTargetExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiAtTargetExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PsiAtArgsExpression.canHaveAnnotation(member.getContainingClass(), getTypeReference(), context, PointcutMatchDegree.TRUE, PointcutMatchDegree.FALSE); - } - - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.TRUE); - } +public class PsiAtTargetExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator { + public PsiAtTargetExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiAtTargetExpression"; + } + + @Nonnull + @Override + @RequiredReadAction + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PsiAtArgsExpression.canHaveAnnotation( + member.getContainingClass(), + getTypeReference(), + context, + PointcutMatchDegree.TRUE, + PointcutMatchDegree.FALSE + ); + } + + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.TRUE); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtThisExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtThisExpression.java index eb18364c..ee509312 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtThisExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtThisExpression.java @@ -1,36 +1,46 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; /** * @author peter */ -public class PsiAtThisExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator{ - - public PsiAtThisExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiAtThisExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PsiAtArgsExpression.canHaveAnnotation(member.getContainingClass(), getTypeReference(), context, PointcutMatchDegree.FALSE, PointcutMatchDegree.FALSE); - } - - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.TRUE); - } +public class PsiAtThisExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator { + public PsiAtThisExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiAtThisExpression"; + } + + @Nonnull + @Override + @RequiredReadAction + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PsiAtArgsExpression.canHaveAnnotation( + member.getContainingClass(), + getTypeReference(), + context, + PointcutMatchDegree.FALSE, + PointcutMatchDegree.FALSE + ); + } + + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.TRUE); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtWithinExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtWithinExpression.java index e4a7aba9..9356dd34 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiAtWithinExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiAtWithinExpression.java @@ -1,37 +1,47 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; /** * @author peter */ -public class PsiAtWithinExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator{ - - public PsiAtWithinExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiAtWithinExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - //todo this is only Spring-specific! - return PsiAtArgsExpression.canHaveAnnotation(member.getContainingClass(), getTypeReference(), context, PointcutMatchDegree.TRUE, PointcutMatchDegree.FALSE); - } - - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.TRUE); - } +public class PsiAtWithinExpression extends PsiTypedPointcutExpression implements PsiAtPointcutDesignator { + public PsiAtWithinExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiAtWithinExpression"; + } + + @Nonnull + @Override + @RequiredReadAction + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + //todo this is only Spring-specific! + return PsiAtArgsExpression.canHaveAnnotation( + member.getContainingClass(), + getTypeReference(), + context, + PointcutMatchDegree.TRUE, + PointcutMatchDegree.FALSE + ); + } + + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.TRUE); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiCallExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiCallExpression.java index dd5a9a82..765770e4 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiCallExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiCallExpression.java @@ -12,18 +12,19 @@ /** * @author peter */ -public class PsiCallExpression extends MethodPatternPointcut{ - public PsiCallExpression(@Nonnull ASTNode node) { - super(node); - } +public class PsiCallExpression extends MethodPatternPointcut { + public PsiCallExpression(@Nonnull ASTNode node) { + super(node); + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } - @Override - public String toString() { - return "PsiCallExpression"; - } + @Override + public String toString() { + return "PsiCallExpression"; + } } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiControlFlowPointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiControlFlowPointcutExpression.java index 733ee2bf..1cc974ac 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiControlFlowPointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiControlFlowPointcutExpression.java @@ -8,29 +8,32 @@ import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.Collections; /** * @author peter */ -public class PsiControlFlowPointcutExpression extends AopElementBase implements PsiPointcutExpression{ - public PsiControlFlowPointcutExpression(@Nonnull ASTNode node) { - super(node); - } +public class PsiControlFlowPointcutExpression extends AopElementBase implements PsiPointcutExpression { + public PsiControlFlowPointcutExpression(@Nonnull ASTNode node) { + super(node); + } - @Override - public String toString() { - return "PsiControlFlowPointcutExpression"; - } + @Override + public String toString() { + return "PsiControlFlowPointcutExpression"; + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } - @Nonnull - public Collection getPatterns() { - return Collections.emptyList(); - } + @Nonnull + @Override + public Collection getPatterns() { + return Collections.emptyList(); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiExecutionExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiExecutionExpression.java index 877d1a61..1ba6b93c 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiExecutionExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiExecutionExpression.java @@ -4,6 +4,7 @@ package com.intellij.aop.psi; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; @@ -15,24 +16,24 @@ * @author peter */ public class PsiExecutionExpression extends MethodPatternPointcut { - public PsiExecutionExpression(@Nonnull ASTNode node) { super(node); } + @Override public String toString() { return "PsiExecutionExpression"; } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - if (!(member instanceof PsiMethod)) return PointcutMatchDegree.FALSE; + if (!(member instanceof PsiMethod method)) return PointcutMatchDegree.FALSE; AopMemberReferenceExpression methodReference = getMethodReference(); if (methodReference == null) return PointcutMatchDegree.FALSE; - PsiMethod method = (PsiMethod)member; - AopReferenceExpression expression = methodReference.getReferenceExpression(); if (expression == null || !expression.getRegex().matcher(method.getName()).matches()) return PointcutMatchDegree.FALSE; @@ -48,10 +49,9 @@ public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember mem if (parameterList != null && parameterList.matches(context, method.getParameterList(), TypeArgumentMatcher.NO_AUTOBOXING) != PointcutMatchDegree.TRUE) return PointcutMatchDegree.FALSE; if (annotationHolder != null && !annotationHolder.accepts(method)) return PointcutMatchDegree.FALSE; - if (processClass(member.getContainingClass(), method, new HashSet(), methodReference.getPatterns())) return PointcutMatchDegree.TRUE; + if (processClass(member.getContainingClass(), method, new HashSet<>(), methodReference.getPatterns())) return PointcutMatchDegree.TRUE; return PointcutMatchDegree.FALSE; - } private static boolean processClass(PsiClass aClass, PsiMethod method, Set visited, Collection patterns) { @@ -75,18 +75,13 @@ private static boolean processClass(PsiClass aClass, PsiMethod method, Set patterns) { - if (AopPsiTypePattern.accepts(patterns, JavaPsiFacade.getInstance(declaringClass.getProject()).getElementFactory().createType( - declaringClass)) == - PointcutMatchDegree.TRUE) { - return true; - } - return false; + return AopPsiTypePattern.accepts(patterns, JavaPsiFacade.getInstance(declaringClass.getProject()) + .getElementFactory().createType(declaringClass)) == PointcutMatchDegree.TRUE; } + @RequiredReadAction private static boolean acceptsReturnType(AopReferenceHolder returnType, PsiType methodReturnType) { if (returnType == null || methodReturnType == null) return true; - if (returnType.accepts(methodReturnType) == PointcutMatchDegree.TRUE) return true; - return false; + return returnType.accepts(methodReturnType) == PointcutMatchDegree.TRUE; } - } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiHandlerPointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiHandlerPointcutExpression.java index 4b66061e..ef3aac23 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiHandlerPointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiHandlerPointcutExpression.java @@ -1,13 +1,13 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; @@ -15,23 +15,24 @@ * @author peter */ public class PsiHandlerPointcutExpression extends PsiTypedPointcutExpression { - - public PsiHandlerPointcutExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiHandlerPointcutExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } - - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.FALSE); - } - + public PsiHandlerPointcutExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiHandlerPointcutExpression"; + } + + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } + + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.FALSE); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiIfPointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiIfPointcutExpression.java index 4ee87f55..7f342bb4 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiIfPointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiIfPointcutExpression.java @@ -1,36 +1,38 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.Collections; /** * @author peter */ -public class PsiIfPointcutExpression extends AopElementBase implements PsiPointcutExpression{ - public PsiIfPointcutExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiIfPointcutExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } - - @Nonnull - public Collection getPatterns() { - return Collections.emptyList(); - } - +public class PsiIfPointcutExpression extends AopElementBase implements PsiPointcutExpression { + public PsiIfPointcutExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiIfPointcutExpression"; + } + + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } + + @Nonnull + @Override + public Collection getPatterns() { + return Collections.emptyList(); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiInitializationPointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiInitializationPointcutExpression.java index 9e5c7a2c..a33e641c 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiInitializationPointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiInitializationPointcutExpression.java @@ -12,21 +12,22 @@ /** * @author peter */ -public class PsiInitializationPointcutExpression extends MethodPatternPointcut{ - private final boolean myPre; +public class PsiInitializationPointcutExpression extends MethodPatternPointcut { + private final boolean myPre; - public PsiInitializationPointcutExpression(@Nonnull ASTNode node, boolean isPre) { - super(node); - myPre = isPre; - } + public PsiInitializationPointcutExpression(@Nonnull ASTNode node, boolean isPre) { + super(node); + myPre = isPre; + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } - @Override - public String toString() { - return "PsiInitializationPointcutExpression"; - } + @Override + public String toString() { + return "PsiInitializationPointcutExpression"; + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiMonitorPointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiMonitorPointcutExpression.java index e3444057..a12302fd 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiMonitorPointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiMonitorPointcutExpression.java @@ -8,29 +8,32 @@ import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.Collections; /** * @author peter */ -public class PsiMonitorPointcutExpression extends AopElementBase implements PsiPointcutExpression{ - public PsiMonitorPointcutExpression(@Nonnull ASTNode node) { - super(node); - } +public class PsiMonitorPointcutExpression extends AopElementBase implements PsiPointcutExpression { + public PsiMonitorPointcutExpression(@Nonnull ASTNode node) { + super(node); + } - @Override - public String toString() { - return "PsiMonitorPointcutExpression"; - } + @Override + public String toString() { + return "PsiMonitorPointcutExpression"; + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } - @Nonnull - public Collection getPatterns() { - return Collections.emptyList(); - } + @Nonnull + @Override + public Collection getPatterns() { + return Collections.emptyList(); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutExpression.java index 9af07e31..4b99f404 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutExpression.java @@ -11,9 +11,10 @@ * @author peter */ public interface PsiPointcutExpression extends AopPatternContainer { - @Nonnull - PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member); + @Nonnull + PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member); - @Nonnull - AopPointcutExpressionFile getContainingFile(); + @Nonnull + @Override + AopPointcutExpressionFile getContainingFile(); } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutReferenceExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutReferenceExpression.java index 03dbe7bd..51c8283d 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutReferenceExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiPointcutReferenceExpression.java @@ -8,6 +8,7 @@ import com.intellij.java.language.psi.PsiMethod; import com.intellij.java.language.psi.PsiParameter; import com.intellij.java.language.psi.PsiParameterList; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import consulo.language.psi.PsiElement; @@ -25,20 +26,25 @@ public PsiPointcutReferenceExpression(@Nonnull ASTNode node) { } @Nullable + @RequiredReadAction public AopReferenceExpression getReferenceExpression() { return findChildByClass(AopReferenceExpression.class); } @Nullable + @RequiredReadAction public AopParameterList getParameterList() { return findChildByClass(AopParameterList.class); } + @Override public String toString() { return "PsiPointcutReferenceExpression"; } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { AopReferenceExpression expression = getReferenceExpression(); if (expression != null) { @@ -54,6 +60,8 @@ public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember mem } @Nonnull + @Override + @RequiredReadAction public Collection getPatterns() { AopReferenceExpression expression = getReferenceExpression(); if (expression != null) { @@ -68,6 +76,7 @@ public Collection getPatterns() { return Arrays.asList(AopPsiTypePattern.FALSE); } + @RequiredReadAction private PointcutContext createContext(PointcutContext context, PsiPointcutExpression pointcutExpression) { PsiMethod pointcutMethod = pointcutExpression.getContainingFile().getAopModel().getPointcutMethod(); PointcutContext newContext = new PointcutContext(pointcutMethod); @@ -79,9 +88,8 @@ private PointcutContext createContext(PointcutContext context, PsiPointcutExpres PsiParameter[] psiParameters = javaList.getParameters(); if (javaList.getParametersCount() == aopParameters.length) { for (int i = 0; i < psiParameters.length; i++) { - PsiElement aopParameter = aopParameters[i]; - if (aopParameter instanceof AopReferenceHolder) { - newContext.addParameter(psiParameters[i].getName(), context.resolve((AopReferenceHolder)aopParameter)); + if (aopParameters[i] instanceof AopReferenceHolder referenceHolder) { + newContext.addParameter(psiParameters[i].getName(), context.resolve(referenceHolder)); } } } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiPrimitiveTypePattern.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiPrimitiveTypePattern.java index f24a2736..bcc57e4d 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiPrimitiveTypePattern.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiPrimitiveTypePattern.java @@ -11,19 +11,19 @@ * @author peter */ public class PsiPrimitiveTypePattern extends AopPsiTypePattern { - private final PsiType myType; + private final PsiType myType; - public PsiPrimitiveTypePattern(@Nonnull PsiType type) { - myType = type; - } + public PsiPrimitiveTypePattern(@Nonnull PsiType type) { + myType = type; + } - public boolean accepts(@Nonnull PsiType type) { - return type.equals(myType); - } - - @Nonnull - public PsiType getType() { - return myType; - } + @Override + public boolean accepts(@Nonnull PsiType type) { + return type.equals(myType); + } + @Nonnull + public PsiType getType() { + return myType; + } } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiStaticInitializationExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiStaticInitializationExpression.java index c1b22b4e..7cd35acf 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiStaticInitializationExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiStaticInitializationExpression.java @@ -1,13 +1,13 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.PsiMember; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; @@ -15,23 +15,24 @@ * @author peter */ public class PsiStaticInitializationExpression extends PsiTypedPointcutExpression { - - public PsiStaticInitializationExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiStaticInitializationExpression"; - } - - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } - - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.FALSE); - } - + public PsiStaticInitializationExpression(@Nonnull ASTNode node) { + super(node); + } + + @Override + public String toString() { + return "PsiStaticInitializationExpression"; + } + + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } + + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.FALSE); + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiTargetExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiTargetExpression.java index 76a96aab..b058258d 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiTargetExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiTargetExpression.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.java.language.psi.*; @@ -19,16 +18,17 @@ * @author peter */ public class PsiTargetExpression extends PsiTypedPointcutExpression { - public PsiTargetExpression(@Nonnull ASTNode node) { super(node); } + @Override public String toString() { return "PsiTargetExpression"; } @Nonnull + @Override public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { PsiClass psiClass = member.getContainingClass(); AopReferenceHolder baseClassPattern = getTypeReference(); @@ -47,6 +47,7 @@ public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember mem } @Nonnull + @Override public Collection getPatterns() { return Arrays.asList(AopPsiTypePattern.TRUE); } @@ -69,7 +70,8 @@ public static PointcutMatchDegree canBeInstanceOf(PsiClass psiClass, boolean all boolean maybe = false; for (AopPsiTypePattern typePattern : typePatterns) { PointcutMatchDegree degree = typePattern.canBeAssignableFrom( - JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory().createType(psiClass)); + JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory().createType(psiClass) + ); if (degree == PointcutMatchDegree.TRUE) return PointcutMatchDegree.TRUE; if (degree == PointcutMatchDegree.MAYBE) maybe = true; } @@ -81,7 +83,7 @@ public static PointcutMatchDegree canBeInstanceOf(boolean allowPatterns, PsiClas if (subClass.getManager().areElementsEquivalent(subClass, superClass) || !allowPatterns && subClass.isInheritor(superClass, true)) { return PointcutMatchDegree.TRUE; } - if (subClass.hasModifierProperty(PsiModifier.FINAL)) return PointcutMatchDegree.FALSE; + if (subClass.isFinal()) return PointcutMatchDegree.FALSE; if (!allowPatterns && superClass.isInterface()) return PointcutMatchDegree.MAYBE; return null; } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiThisExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiThisExpression.java index 58bdd678..9b30a84f 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiThisExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiThisExpression.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.aop.psi; import com.intellij.aop.AopIntroduction; @@ -10,6 +9,7 @@ import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiElementFactory; import com.intellij.java.language.psi.PsiMember; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; @@ -20,16 +20,18 @@ * @author peter */ public class PsiThisExpression extends PsiTypedPointcutExpression { - public PsiThisExpression(@Nonnull ASTNode node) { super(node); } + @Override public String toString() { return "PsiThisExpression"; } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { AopReferenceHolder reference = getTypeReference(); if (reference == null) return PointcutMatchDegree.FALSE; @@ -56,6 +58,7 @@ public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember mem } @Nonnull + @Override public Collection getPatterns() { return Arrays.asList(AopPsiTypePattern.TRUE); } diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinCodePointcutExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinCodePointcutExpression.java index 3beeb733..bfaaf32f 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinCodePointcutExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinCodePointcutExpression.java @@ -13,18 +13,18 @@ * @author peter */ public class PsiWithinCodePointcutExpression extends MethodPatternPointcut { + public PsiWithinCodePointcutExpression(@Nonnull ASTNode node) { + super(node); + } - public PsiWithinCodePointcutExpression(@Nonnull ASTNode node) { - super(node); - } + @Nonnull + @Override + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + return PointcutMatchDegree.FALSE; + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return PointcutMatchDegree.FALSE; - } - - @Override - public String toString() { - return "PsiWithinCodePointcutExpression"; - } + @Override + public String toString() { + return "PsiWithinCodePointcutExpression"; + } } \ No newline at end of file diff --git a/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinExpression.java b/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinExpression.java index 51613899..20020264 100644 --- a/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinExpression.java +++ b/aop-common/src/main/java/com/intellij/aop/psi/PsiWithinExpression.java @@ -6,9 +6,11 @@ import com.intellij.java.language.psi.JavaPsiFacade; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiMember; +import consulo.annotation.access.RequiredReadAction; import consulo.language.ast.ASTNode; import jakarta.annotation.Nonnull; + import java.util.Arrays; import java.util.Collection; @@ -16,32 +18,40 @@ * @author peter */ public class PsiWithinExpression extends PsiTypedPointcutExpression { + public PsiWithinExpression(@Nonnull ASTNode node) { + super(node); + } - public PsiWithinExpression(@Nonnull ASTNode node) { - super(node); - } - - public String toString() { - return "PsiWithinExpression"; - } + @Override + public String toString() { + return "PsiWithinExpression"; + } - @Nonnull - public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - AopReferenceHolder holder = getTypeReference(); - if (holder == null) return PointcutMatchDegree.FALSE; + @Nonnull + @Override + @RequiredReadAction + public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { + AopReferenceHolder holder = getTypeReference(); + if (holder == null) { + return PointcutMatchDegree.FALSE; + } + + PsiClass psiClass = member.getContainingClass(); + PointcutMatchDegree degree = PointcutMatchDegree.FALSE; + while (psiClass != null) { + degree = PointcutMatchDegree.or( + degree, + holder.accepts(JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory().createType(psiClass)) + ); + psiClass = psiClass.getContainingClass(); + } + return degree; - PsiClass psiClass = member.getContainingClass(); - PointcutMatchDegree degree = PointcutMatchDegree.FALSE; - while (psiClass != null) { - degree = PointcutMatchDegree.or(degree, holder.accepts(JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory().createType(psiClass))); - psiClass = psiClass.getContainingClass(); } - return degree; - - } - @Nonnull - public Collection getPatterns() { - return Arrays.asList(AopPsiTypePattern.TRUE); - } + @Nonnull + @Override + public Collection getPatterns() { + return Arrays.asList(AopPsiTypePattern.TRUE); + } } diff --git a/aop-common/tests/com/intellij/aop/psi/PointcutAcceptTest.java b/aop-common/tests/com/intellij/aop/psi/PointcutAcceptTest.java index 73e02f2f..0758bd2b 100644 --- a/aop-common/tests/com/intellij/aop/psi/PointcutAcceptTest.java +++ b/aop-common/tests/com/intellij/aop/psi/PointcutAcceptTest.java @@ -83,6 +83,7 @@ protected void tuneFixture(JavaModuleFixtureBuilder moduleBuilder) { private void createAopPoincut(final PsiMethod method) { new AopPointcutImpl() { @Nonnull + @Override public PsiMethod getPsiElement() { return method; } diff --git a/aop-common/tests/com/intellij/aop/psi/PsiTypePatternsTest.java b/aop-common/tests/com/intellij/aop/psi/PsiTypePatternsTest.java index 9d268c9d..b9999206 100644 --- a/aop-common/tests/com/intellij/aop/psi/PsiTypePatternsTest.java +++ b/aop-common/tests/com/intellij/aop/psi/PsiTypePatternsTest.java @@ -273,12 +273,10 @@ public void testProcessPackages() throws Throwable { } private void assertPackages(AopPsiTypePattern pattern, String... packages) { - final Set actual = new THashSet(); - assertTrue(pattern.processPackages(getPsiManager(), new Processor() { - public boolean process(PsiPackage psiPackage) { - actual.add(psiPackage.getQualifiedName()); - return true; - } + Set actual = new THashSet(); + assertTrue(pattern.processPackages(getPsiManager(), psiPackage -> { + actual.add(psiPackage.getQualifiedName()); + return true; })); assertTrue(actual.containsAll(Arrays.asList(packages))); } @@ -289,5 +287,4 @@ public void testAnnotatedPattern() throws Throwable { assertFalse(pattern.accepts(createPsiType("java.lang.Object"))); assertFalse(pattern.accepts(createPsiType("FooAnno"))); } - } diff --git a/java-ex-impl/src/main/java/consulo/java/ex/facet/RemoteRepositoryInfo.java b/java-ex-impl/src/main/java/consulo/java/ex/facet/RemoteRepositoryInfo.java index aec9fc30..56110204 100644 --- a/java-ex-impl/src/main/java/consulo/java/ex/facet/RemoteRepositoryInfo.java +++ b/java-ex-impl/src/main/java/consulo/java/ex/facet/RemoteRepositoryInfo.java @@ -13,13 +13,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package consulo.java.ex.facet; import consulo.logging.Logger; -import org.jetbrains.annotations.Nls; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; /** @@ -31,7 +27,7 @@ public class RemoteRepositoryInfo { private final String myPresentableName; private final String[] myMirrors; - public RemoteRepositoryInfo(@Nonnull @NonNls String id, @Nonnull @Nls String presentableName, @Nonnull @NonNls String[] mirrors) { + public RemoteRepositoryInfo(@Nonnull String id, @Nonnull String presentableName, @Nonnull String[] mirrors) { myId = id; LOG.assertTrue(mirrors.length > 0); myPresentableName = presentableName; @@ -54,15 +50,16 @@ public String getDefaultMirror() { return myMirrors[0]; } + @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; RemoteRepositoryInfo that = (RemoteRepositoryInfo)o; return myId.equals(that.myId); - } + @Override public int hashCode() { return myId.hashCode(); } diff --git a/plugin/src/main/java/com/intellij/spring/impl/SpringManagerImpl.java b/plugin/src/main/java/com/intellij/spring/impl/SpringManagerImpl.java index b9fa25c5..1b4f7931 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/SpringManagerImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/SpringManagerImpl.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2006 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl; import com.intellij.java.impl.util.xml.converters.values.GenericDomValueConvertersRegistry; @@ -46,7 +45,6 @@ @Singleton @ServiceImpl public class SpringManagerImpl extends SpringManager { - @Deprecated private final SpringModelFactory myModelFactory; private final GenericDomValueConvertersRegistry myValueProvidersRegistry; @@ -83,12 +81,13 @@ private void registerValueConverters() { myValueProvidersRegistry.registerConverter(new EnumValueConverter(), new EnumValueConverter.TypeCondition()); } - @RequiredReadAction @Override + @RequiredReadAction public SpringModel getModel(@Nonnull Module module) { - return myCachedValuesManager.getCachedValue(module, () -> { - return CachedValueProvider.Result.create(getModelImpl(module), PsiModificationTracker.MODIFICATION_COUNT); - }); + return myCachedValuesManager.getCachedValue( + module, + () -> CachedValueProvider.Result.create(getModelImpl(module), PsiModificationTracker.MODIFICATION_COUNT) + ); } @RequiredReadAction @@ -143,7 +142,6 @@ public List getAllModels(@Nonnull consulo.module.Module module) { return list; } - @RequiredReadAction private SpringModel getCombinedModelImpl(Module module) { List allModels = getAllModels(module); @@ -181,12 +179,10 @@ public SpringModel getSpringModelByFile(@Nonnull XmlFile file) { @Override @Nullable + @RequiredReadAction public SpringModel getLocalSpringModel(@Nonnull XmlFile file) { DomFileElement beans = myModelFactory.getDomRoot(file); - return beans == null ? null : new DomSpringModelImpl2(beans, - Collections.singleton(file), - ModuleUtilCore.findModuleForPsiElement(file), - null); + return beans == null ? null : new DomSpringModelImpl2(beans, Collections.singleton(file), file.getModule(), null); } @Override @@ -203,8 +199,9 @@ public List getProvidedModels(@Nonnull SpringModuleExtension exte @Override @Nonnull + @RequiredReadAction public Set getAllSets(@Nonnull SpringModuleExtension extension) { - Set fileSets = new HashSet(extension.getFileSets()); + Set fileSets = new HashSet<>(extension.getFileSets()); List providedModels = getProvidedModels(extension); fileSets.addAll(providedModels); return fileSets; diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/PNamespaceDescriptor.java b/plugin/src/main/java/com/intellij/spring/impl/ide/PNamespaceDescriptor.java index a6ac922b..f85ea700 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/PNamespaceDescriptor.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/PNamespaceDescriptor.java @@ -13,20 +13,20 @@ import com.intellij.xml.impl.schema.XmlNSDescriptorImpl; import consulo.language.psi.PsiElement; import consulo.language.psi.meta.PsiPresentableMetaData; +import consulo.spring.impl.icon.SpringImplIconGroup; import consulo.ui.image.Image; import consulo.util.collection.ArrayUtil; import consulo.util.lang.StringUtil; import consulo.xml.descriptor.XmlAttributeDescriptor; import consulo.xml.descriptor.XmlElementDescriptor; +import consulo.xml.dom.DomElement; +import consulo.xml.dom.DomManager; import consulo.xml.language.psi.XmlDocument; import consulo.xml.language.psi.XmlElement; import consulo.xml.language.psi.XmlTag; -import consulo.xml.dom.DomElement; -import consulo.xml.dom.DomManager; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -35,7 +35,7 @@ * @author peter */ public class PNamespaceDescriptor extends XmlNSDescriptorImpl { - + @Override public XmlAttributeDescriptor getAttribute(String localName, String namespace, XmlTag context) { // TODO: this is not efficient! if (SpringConstants.P_NAMESPACE.equals(namespace)) { @@ -50,8 +50,7 @@ public XmlAttributeDescriptor getAttribute(String localName, String namespace, X public static PsiClass getClass(@Nonnull XmlTag tag) { DomElement element = DomManager.getDomManager(tag.getProject()).getDomElement(tag); - if (element instanceof SpringBean) { - SpringBean bean = (SpringBean)element; + if (element instanceof SpringBean bean) { return bean.getBeanClass(); } return null; @@ -62,7 +61,7 @@ private static XmlAttributeDescriptor[] getAttributeDescriptors(@Nonnull XmlTag if (psiClass == null) { return XmlAttributeDescriptor.EMPTY; } - List result = new ArrayList(); + List result = new ArrayList<>(); Map properties = PropertyUtil.getAllProperties(psiClass, true, false); for (String propertyName : properties.keySet()) { @@ -77,43 +76,48 @@ private static XmlAttributeDescriptor[] getAttributeDescriptors(@Nonnull XmlTag } @Nonnull + @Override public XmlElementDescriptor[] getRootElementsDescriptors(@Nullable XmlDocument doc) { return XmlElementDescriptor.EMPTY_ARRAY; } + @Override public XmlAttributeDescriptor[] getRootAttributeDescriptors(XmlTag context) { return getAttributeDescriptors(context); } - private static class PAttributeDescriptor implements XmlAttributeDescriptorEx, PsiPresentableMetaData { private final String myPropertyName; private final String mySuffix; private final PsiMethod myMethod; - public PAttributeDescriptor(@NonNls String propertyName, @NonNls String suffix, PsiMethod method) { + public PAttributeDescriptor(String propertyName, String suffix, PsiMethod method) { myPropertyName = propertyName; mySuffix = suffix; myMethod = method; } + @Override public String getName() { return myPropertyName + mySuffix; } + @Override public void init(PsiElement element) { throw new UnsupportedOperationException("Method init is not yet implemented in " + getClass().getName()); } + @Override public Object[] getDependences() { return ArrayUtil.EMPTY_OBJECT_ARRAY; } + @Override public PsiElement getDeclaration() { return myMethod; } - @NonNls + @Override public String getName(PsiElement context) { String name = getName(); String prefix = ((XmlTag)context).getPrefixByNamespace(SpringConstants.P_NAMESPACE); @@ -121,54 +125,63 @@ public String getName(PsiElement context) { return name; } + @Override public boolean isRequired() { return false; } + @Override public boolean isFixed() { return false; } + @Override public boolean hasIdType() { return false; } + @Override public boolean hasIdRefType() { return false; } @Nullable + @Override public String getDefaultValue() { return null; } + @Override public boolean isEnumerated() { return false; } + @Override public String[] getEnumeratedValues() { return ArrayUtil.EMPTY_STRING_ARRAY; } @Nullable + @Override public String validateValue(XmlElement context, String value) { return null; } + @Override public String getTypeName() { throw new UnsupportedOperationException("Method getTypeName is not yet implemented in " + getClass().getName()); } @Nullable + @Override public Image getIcon() { - return SpringIcons.SPRING_BEAN_PROPERTY_ICON; + return SpringImplIconGroup.springproperty(); } - @NonNls - public String handleTargetRename(@Nonnull @NonNls String newTargetName) { + @Override + public String handleTargetRename(@Nonnull String newTargetName) { String propertyName = PropertyUtil.getPropertyName(newTargetName); return propertyName == null ? null : propertyName + mySuffix; - } } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/factories/resolvers/ProxyFactoryBeanTypeResolver.java b/plugin/src/main/java/com/intellij/spring/impl/ide/factories/resolvers/ProxyFactoryBeanTypeResolver.java index 55697bd4..683ebdbd 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/factories/resolvers/ProxyFactoryBeanTypeResolver.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/factories/resolvers/ProxyFactoryBeanTypeResolver.java @@ -8,10 +8,9 @@ import consulo.language.psi.PsiManager; import consulo.language.psi.scope.GlobalSearchScope; import consulo.project.Project; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Collections; import java.util.Set; @@ -32,20 +31,20 @@ */ @SuppressWarnings({"UnnecessaryFullyQualifiedName"}) public class ProxyFactoryBeanTypeResolver extends AbstractProxiedTypeResolver { - @NonNls private static final String FACTORY_CLASS = "org.springframework.aop.framework.ProxyFactoryBean"; + private static final String FACTORY_CLASS = "org.springframework.aop.framework.ProxyFactoryBean"; - @NonNls private static final String PROXY_INTERFACES_PROPERTY_NAME = "proxyInterfaces"; - @NonNls private static final String INTERFACES_PROPERTY_NAME = "interfaces"; - @NonNls private static final String AUTODETECT_INTERFACES_PROPERTY_NAME = "autodetectInterfaces"; + private static final String PROXY_INTERFACES_PROPERTY_NAME = "proxyInterfaces"; + private static final String INTERFACES_PROPERTY_NAME = "interfaces"; + private static final String AUTODETECT_INTERFACES_PROPERTY_NAME = "autodetectInterfaces"; - @NonNls private static final String TARGET_PROPERTY_NAME = "target"; - @NonNls private static final String TARGET_NAME_PROPERTY_NAME = "targetName"; - @NonNls private static final String TARGET_CLASS_PROPERTY_NAME = "targetClass"; + private static final String TARGET_PROPERTY_NAME = "target"; + private static final String TARGET_NAME_PROPERTY_NAME = "targetName"; + private static final String TARGET_CLASS_PROPERTY_NAME = "targetClass"; @Nonnull + @Override public Set getObjectType(@Nonnull CommonSpringBean context) { - if (context instanceof SpringBean) { - SpringBean springBean = (SpringBean) context; + if (context instanceof SpringBean springBean) { PsiClassType type = getTargetType(springBean); if (isCglibExplicitlyEnabled(springBean) && type != null) { @@ -106,6 +105,7 @@ private static boolean isAutodetectInterfacesEnabled(@Nonnull SpringBean context return !isBooleanProperySetAndFalse(context, AUTODETECT_INTERFACES_PROPERTY_NAME); } + @Override public boolean accept(@Nonnull String factoryClassName) { return FACTORY_CLASS.equals(factoryClassName); } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/PatternFileReferenceSet.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/PatternFileReferenceSet.java index 39ffcd4f..557f34de 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/PatternFileReferenceSet.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/PatternFileReferenceSet.java @@ -1,10 +1,9 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.converters; -import com.intellij.spring.impl.ide.SpringBundle; +import consulo.annotation.access.RequiredReadAction; import consulo.document.util.TextRange; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiElementResolveResult; @@ -12,9 +11,10 @@ import consulo.language.psi.ResolveResult; import consulo.language.psi.path.FileReference; import consulo.language.psi.path.FileReferenceSet; +import consulo.spring.localize.SpringLocalize; import consulo.util.io.FileUtil; - import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.regex.Pattern; @@ -23,11 +23,11 @@ */ public class PatternFileReferenceSet extends FileReferenceSet { - public PatternFileReferenceSet(String str, PsiElement element, int offset) { super(str, element, offset, null, true); } + @Override public FileReference createFileReference(TextRange range, int index, String text) { if (!isAntPattern(text)) return super.createFileReference(range, index, text); @@ -39,6 +39,7 @@ static boolean isAntPattern(String str) { return (str.indexOf('*') != -1 || str.indexOf('?') != -1); } + @Override protected boolean isSoft() { return true; } @@ -52,11 +53,14 @@ public PatternFileReference(FileReferenceSet referenceSet, TextRange range, int super(referenceSet, range, index, text); } - protected void innerResolveInContext(@Nonnull String text, - @Nonnull PsiFileSystemItem context, - Collection result, boolean caseSensitive) { - - + @Override + @RequiredReadAction + protected void innerResolveInContext( + @Nonnull String text, + @Nonnull PsiFileSystemItem context, + Collection result, + boolean caseSensitive + ) { if (text.equals("**")) { addDirectoryResolves(context, result); } @@ -66,17 +70,16 @@ protected void innerResolveInContext(@Nonnull String text, PsiElement[] psiElements = context.getChildren(); for (PsiElement psiElement : psiElements) { - if (psiElement instanceof PsiFileSystemItem) { - if (pattern.matcher(((PsiFileSystemItem)psiElement).getName()).matches()) { - result.add(new PsiElementResolveResult(psiElement)); - } + if (psiElement instanceof PsiFileSystemItem fsItem && pattern.matcher(fsItem.getName()).matches()) { + result.add(new PsiElementResolveResult(fsItem)); } } } } + @RequiredReadAction private static void addDirectoryResolves(PsiElement context, Collection result) { - if (context instanceof PsiFileSystemItem && ((PsiFileSystemItem)context).isDirectory()) { + if (context instanceof PsiFileSystemItem fsItem && fsItem.isDirectory()) { result.add(new PsiElementResolveResult(context)); for (PsiElement psiElement : context.getChildren()) { addDirectoryResolves(psiElement, result); @@ -85,7 +88,7 @@ private static void addDirectoryResolves(PsiElement context, Collection implements CustomReferenceConverter { - protected final static Object[] EMPTY_ARRAY = ArrayUtil.EMPTY_OBJECT_ARRAY; private final MethodAccepter myMethodAccepter; @@ -47,12 +50,11 @@ public PsiMethodConverter() { protected static class MethodAccepter { public boolean accept(PsiMethod method) { - return !method.isConstructor() && - method.hasModifierProperty(PsiModifier.PUBLIC) && - !method.hasModifierProperty(PsiModifier.STATIC); + return !method.isConstructor() && method.isPublic() && !method.isStatic(); } } + @Override public PsiMethod fromString(@Nullable String methodName, ConvertContext context) { if (methodName == null || methodName.length() == 0) { return null; @@ -76,6 +78,7 @@ public PsiMethod fromString(@Nullable String methodName, ConvertContext context) } } + @Override public String toString(@Nullable PsiMethod psiMethods, ConvertContext context) { return null; } @@ -87,12 +90,13 @@ protected MethodAccepter getMethodAccepter(ConvertContext context, boolean forCo return myMethodAccepter; } + @RequiredReadAction private Object[] getVariants(ConvertContext context) { PsiClass psiClass = getPsiClass(context); if (psiClass == null) { return EMPTY_ARRAY; } - ArrayList result = new ArrayList(); + List result = new ArrayList<>(); MethodAccepter methodAccepter = getMethodAccepter(context, true); PsiMethod[] methods; if (psiClass.isEnum()) { @@ -122,10 +126,8 @@ private Object[] getVariants(ConvertContext context) { } @Nonnull - public PsiReference[] createReferences(GenericDomValue genericDomValue, - PsiElement element, - ConvertContext context) { - + @Override + public PsiReference[] createReferences(GenericDomValue genericDomValue, PsiElement element, ConvertContext context) { return new PsiReference[]{new MyReference(element, genericDomValue, context)}; } @@ -133,27 +135,31 @@ protected class MyReference extends PsiReferenceBase implements Empt private final GenericDomValue myGenericDomValue; private final ConvertContext myContext; - public MyReference(PsiElement element, - GenericDomValue genericDomValue, - ConvertContext context) { + public MyReference(PsiElement element, GenericDomValue genericDomValue, ConvertContext context) { super(element); myGenericDomValue = genericDomValue; myContext = context; } + @Override + @RequiredReadAction public Object[] getVariants() { return PsiMethodConverter.this.getVariants(myContext); } @Nullable + @Override + @RequiredReadAction public PsiElement resolve() { return myGenericDomValue.getValue(); } + @Override public boolean isSoft() { return true; } + @Override public PsiElement bindToElement(@Nonnull PsiElement element) throws IncorrectOperationException { assert element instanceof PsiMethod : "PsiMethod expected"; PsiMethod psiMethod = (PsiMethod)element; @@ -161,6 +167,7 @@ public PsiElement bindToElement(@Nonnull PsiElement element) throws IncorrectOpe return psiMethod; } + @Override public LocalQuickFix[] getQuickFixes() { return PsiMethodConverter.this.getQuickFixes(myContext); } @@ -168,7 +175,7 @@ public LocalQuickFix[] getQuickFixes() { @Nonnull @Override public LocalizeValue buildUnresolvedMessage(@Nonnull String s) { - return LocalizeValue.localizeTODO(SpringBundle.message("cannot.resolve.method", myGenericDomValue.getStringValue())); + return SpringLocalize.cannotResolveMethod(myGenericDomValue.getStringValue()); } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ReplacedMethodBeanConverter.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ReplacedMethodBeanConverter.java index 86ab8da1..f7d1595e 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ReplacedMethodBeanConverter.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ReplacedMethodBeanConverter.java @@ -1,22 +1,21 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.converters; import com.intellij.spring.impl.ide.model.highlighting.ReplacedMethodsInspection; import consulo.xml.dom.ConvertContext; -import org.jetbrains.annotations.NonNls; import jakarta.annotation.Nonnull; /** * @see ReplacedMethodsInspection */ public class ReplacedMethodBeanConverter extends SpringBeanResolveConverterForDefiniteClasses { - @NonNls public final static String METHOD_REPLACER_CLASS = "org.springframework.beans.factory.support.MethodReplacer"; + public final static String METHOD_REPLACER_CLASS = "org.springframework.beans.factory.support.MethodReplacer"; - @Nonnull - protected String[] getClassNames(ConvertContext context) { - return new String[]{METHOD_REPLACER_CLASS}; - } + @Nonnull + @Override + protected String[] getClassNames(ConvertContext context) { + return new String[]{METHOD_REPLACER_CLASS}; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ResourceResolverUtils.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ResourceResolverUtils.java index a3e625de..b7591367 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ResourceResolverUtils.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/converters/ResourceResolverUtils.java @@ -1,19 +1,18 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.converters; import com.intellij.java.impl.psi.impl.source.resolve.reference.impl.providers.FilePathReferenceProvider; import com.intellij.spring.impl.ide.model.xml.beans.ListOrSet; import com.intellij.spring.impl.ide.model.xml.beans.SpringProperty; import com.intellij.spring.impl.ide.model.xml.beans.SpringValue; +import consulo.annotation.access.RequiredReadAction; import consulo.document.util.TextRange; import consulo.language.content.LanguageContentFolderScopes; import consulo.language.psi.*; import consulo.language.psi.path.FileReference; import consulo.language.psi.path.FileReferenceSet; -import consulo.language.util.ModuleUtilCore; import consulo.module.Module; import consulo.module.content.ModuleRootManager; import consulo.module.content.ProjectFileIndex; @@ -21,42 +20,35 @@ import consulo.module.content.layer.ContentFolder; import consulo.util.collection.ContainerUtil; import consulo.util.lang.StringUtil; -import consulo.util.lang.function.Condition; -import consulo.util.lang.function.PairProcessor; import consulo.util.lang.text.StringTokenizer; import consulo.virtualFileSystem.VirtualFile; import consulo.virtualFileSystem.util.VirtualFileUtil; +import consulo.xml.dom.*; import consulo.xml.language.psi.XmlAttribute; import consulo.xml.language.psi.XmlTag; -import consulo.xml.dom.*; import consulo.xml.util.xml.impl.ConvertContextImpl; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.List; +import java.util.function.BiPredicate; +import java.util.function.Predicate; public class ResourceResolverUtils { - @NonNls private static final String CLASSPATH_PREFIX = "classpath:"; - @NonNls private static final String CLASSPATH_PREFIX_ASTERISK = "classpath*:"; - @NonNls private static final String FILE_PREFIX = "file:"; - @NonNls private static final String HTTP_PREFIX = "http:"; + private static final String CLASSPATH_PREFIX = "classpath:"; + private static final String CLASSPATH_PREFIX_ASTERISK = "classpath*:"; + private static final String FILE_PREFIX = "file:"; + private static final String HTTP_PREFIX = "http:"; - public static final Condition FILE_FILTER = new Condition() { - public boolean value(PsiFileSystemItem item) { - return item instanceof PsiFile; - } - }; - public static final Condition DIRECTORY_FILTER = new Condition() { - public boolean value(PsiFileSystemItem item) { - return item instanceof PsiDirectory; - } - }; + public static final Predicate FILE_FILTER = item -> item instanceof PsiFile; + public static final Predicate DIRECTORY_FILTER = item -> item instanceof PsiDirectory; private static final FilePathReferenceProvider ourFilePathReferenceProvider = new FilePathReferenceProvider() { + @Override protected FileReference createFileReference(FileReferenceSet referenceSet, TextRange range, int index, @@ -70,12 +62,12 @@ protected FileReference createFileReference(FileReferenceSet referenceSet, private ResourceResolverUtils() { } - public static boolean processSpringValues(SpringProperty property, PairProcessor processor) { + public static boolean processSpringValues(SpringProperty property, BiPredicate processor) { { GenericAttributeValue valueAttr = property.getValueAttr(); XmlAttribute valueAttrElement = valueAttr.getXmlAttribute(); String valueAttrString = valueAttr.getStringValue(); - if (valueAttrElement != null && valueAttrString != null && !processor.process(valueAttr, valueAttrString)) { + if (valueAttrElement != null && valueAttrString != null && !processor.test(valueAttr, valueAttrString)) { return false; } } @@ -83,7 +75,7 @@ public static boolean processSpringValues(SpringProperty property, PairProcessor SpringValue value = property.getValue(); XmlTag valueElement = value.getXmlTag(); String valueString = value.getStringValue(); - if (valueElement != null && valueString != null && !processor.process(value, valueString)) { + if (valueElement != null && valueString != null && !processor.test(value, valueString)) { return false; } } @@ -92,7 +84,7 @@ public static boolean processSpringValues(SpringProperty property, PairProcessor for (SpringValue springValue : listOrSet.getValues()) { XmlTag element = springValue.getXmlTag(); String string = springValue.getStringValue(); - if (element != null && string != null && !processor.process(springValue, string)) { + if (element != null && string != null && !processor.test(springValue, string)) { return false; } } @@ -100,73 +92,73 @@ public static boolean processSpringValues(SpringProperty property, PairProcessor return true; } - public static > T getResourceItems(@Nonnull SpringProperty property, final T result, final Condition filter) { - processSpringValues(property, new PairProcessor() { - public boolean process(GenericDomValue domValue, String s) { - Object value = domValue.getValue(); - if (value instanceof Collection) { - for (Object o : (Collection)value) { - if (o instanceof PsiFileSystemItem && filter.value((PsiFileSystemItem)o)) { - result.add((V)o); - } + @SuppressWarnings("unchecked") + public static > T getResourceItems(@Nonnull SpringProperty property, T result, Predicate filter) { + processSpringValues(property, (domValue, s) -> { + if (domValue.getValue() instanceof Collection collection) { + for (Object o : collection) { + if (o instanceof PsiFileSystemItem && filter.test((PsiFileSystemItem)o)) { + result.add((V)o); } } - return true; } + return true; }); return result; } + @RequiredReadAction public static > T addResourceFilesFrom(@Nonnull PsiElement element, @Nonnull String s, - T result, Condition filter) { + T result, Predicate filter) { PsiReference[] references = getReferences(element, s, false, false); return addResourceItems(result, references, filter); } - public static > T addResourceFilesFrom(final @Nonnull PsiElement element, @Nonnull String s, String delimiter, - T result, Condition filter) { - final ArrayList references = new ArrayList(); - final int startInElement = ElementManipulators.getOffsetInElement(element); - - processSeparatedString(s, delimiter, new PairProcessor() { - public boolean process(String s, Integer offset) { - PsiReference[] psiReferences = getReferences(element, s, false, false, offset.intValue() + startInElement, true); - references.addAll(Arrays.asList(psiReferences)); - return true; - } + @RequiredReadAction + public static > T addResourceFilesFrom( + @Nonnull PsiElement element, + @Nonnull String s, + String delimiter, + T result, + Predicate filter + ) { + List references = new ArrayList<>(); + int startInElement = ElementManipulators.getOffsetInElement(element); + + processSeparatedString(s, delimiter, (s1, offset) -> { + PsiReference[] psiReferences = getReferences(element, s1, false, false, offset + startInElement, true); + references.addAll(Arrays.asList(psiReferences)); + return true; }); return addResourceItems(result, references.toArray(new PsiReference[references.size()]) , filter); } + @RequiredReadAction public static > T addResourceFilesFrom(@Nonnull GenericDomValue element, @Nonnull String s, T result, - Condition filter) { + Predicate filter) { Converter converter = WrappingConverter.getDeepestConverter(element.getConverter(), element); - if (converter instanceof CustomReferenceConverter) { - PsiReference[] references = ((CustomReferenceConverter)converter).createReferences(element, element.getXmlElement(), - new ConvertContextImpl(element)); + if (converter instanceof CustomReferenceConverter customRefConverter) { + PsiReference[] references = customRefConverter.createReferences(element, element.getXmlElement(), new ConvertContextImpl(element)); return addResourceItems(result, references, filter); } return result; } - private static > T addResourceItems(T result, PsiReference[] references, Condition filter) { + @RequiredReadAction + @SuppressWarnings("unchecked") + private static > T addResourceItems(T result, PsiReference[] references, Predicate filter) { for (PsiReference reference : references) { - if (reference instanceof PsiPolyVariantReference) { - ResolveResult[] resolveResults = ((PsiPolyVariantReference)reference).multiResolve(false); - for (ResolveResult resolveResult : resolveResults) { - PsiElement psiElement = resolveResult.getElement(); - if (psiElement instanceof PsiFileSystemItem && filter.value((PsiFileSystemItem)psiElement)) { - result.add((V)psiElement); + if (reference instanceof PsiPolyVariantReference polyVariantRef) { + for (ResolveResult resolveResult : polyVariantRef.multiResolve(false)) { + if (resolveResult.getElement() instanceof PsiFileSystemItem fsItem && filter.test(fsItem)) { + result.add((V) fsItem); } } } - else { - PsiElement psiElement = reference.resolve(); - if (psiElement instanceof PsiFileSystemItem && filter.value((PsiFileSystemItem)psiElement)) { - result.add((V)psiElement); - } + else if (reference.resolve() instanceof PsiFileSystemItem fsItem && filter.test(fsItem)) { + result.add((V) fsItem); } } return result; @@ -241,25 +233,26 @@ public static PsiReference[] getClassPathReferences(PsiElement element, String s return ourFilePathReferenceProvider.getReferencesByElement(element, s, offset, soft); } - public static boolean processSeparatedString(String str, String delimiter, PairProcessor processor) { + public static boolean processSeparatedString(String str, String delimiter, BiPredicate processor) { if (str == null || StringUtil.isEmptyOrSpaces(str)) return true; StringTokenizer tokenizer = new StringTokenizer(str, delimiter); while (tokenizer.hasMoreElements()) { - @NonNls String s = tokenizer.nextElement().trim(); + String s = tokenizer.nextElement().trim(); if (s.length() == 0) continue; - if (!processor.process(s, str.indexOf(s))) return false; + if (!processor.test(s, str.indexOf(s))) return false; } return true; } @Nullable + @RequiredReadAction public static String getResourceFileReferenceString(PsiFile resourceFile) { VirtualFile virtualFile = resourceFile == null ? null : resourceFile.getVirtualFile(); if (virtualFile == null) return null; - Module moduleForFile = ModuleUtilCore.findModuleForFile(resourceFile); + Module moduleForFile = resourceFile.getModule(); if (moduleForFile != null) { for (ContentFolder folder : ModuleRootManager.getInstance(moduleForFile) .getContentFolders(LanguageContentFolderScopes.production())) { diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/highlighting/ReplacedMethodsInspection.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/highlighting/ReplacedMethodsInspection.java index 184e6356..2fc315e0 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/highlighting/ReplacedMethodsInspection.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/highlighting/ReplacedMethodsInspection.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.highlighting; import com.intellij.java.impl.codeInsight.daemon.impl.quickfix.ExtendsListFix; @@ -24,6 +23,7 @@ @ExtensionImpl public class ReplacedMethodsInspection extends SpringBeanInspectionBase { + @Override protected void checkBean( SpringBean springBean, Beans beans, diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReference.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReference.java index 3fd4dc24..128e1598 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReference.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReference.java @@ -1,19 +1,22 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.properties; import com.intellij.java.impl.psi.impl.beanProperties.CreateBeanPropertyFix; -import com.intellij.java.language.psi.*; +import com.intellij.java.language.psi.PsiClass; +import com.intellij.java.language.psi.PsiClassType; +import com.intellij.java.language.psi.PsiMethod; +import com.intellij.java.language.psi.PsiType; import com.intellij.java.language.psi.util.InheritanceUtil; import com.intellij.java.language.psi.util.PropertyUtil; -import com.intellij.spring.impl.ide.SpringBundle; import com.intellij.spring.impl.ide.SpringModel; import com.intellij.spring.impl.ide.model.converters.SpringConverterUtil; import com.intellij.spring.impl.ide.model.xml.beans.SpringBaseBeanPointer; import com.intellij.spring.impl.ide.model.xml.beans.SpringBeanPointer; import com.intellij.spring.impl.ide.model.xml.beans.SpringPropertyDefinition; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.document.util.TextRange; import consulo.language.editor.completion.lookup.LookupValueFactory; import consulo.language.editor.inspection.LocalQuickFix; @@ -21,12 +24,13 @@ import consulo.language.psi.*; import consulo.language.util.IncorrectOperationException; import consulo.localize.LocalizeValue; -import consulo.spring.impl.SpringIcons; +import consulo.spring.impl.icon.SpringImplIconGroup; +import consulo.spring.localize.SpringLocalize; import consulo.util.collection.ContainerUtil; import consulo.util.lang.StringUtil; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.*; import java.util.function.Function; @@ -35,7 +39,6 @@ */ public class PropertyReference extends PsiReferenceBase implements PsiPolyVariantReference, EmptyResolveMessageProvider, LocalQuickFixProvider { - private final PropertyReferenceSet myReferenceSet; private final int myIndex; @@ -56,9 +59,8 @@ private PsiClass getPsiClass() { ResolveResult[] results = myReferenceSet.getReference(myIndex - 1).multiResolve(false); if (results.length > 0) { PsiMethod method = chooseMethod(ContainerUtil.map2List(results, resolveResult -> (PsiMethod)resolveResult.getElement())); - PsiType type = method.getReturnType(); - if (type instanceof PsiClassType) { - return ((PsiClassType)type).resolve(); + if (method.getReturnType() instanceof PsiClassType classType) { + return classType.resolve(); } } } @@ -70,7 +72,7 @@ private Set getSharedProperties(@Nonnull Collection maps = new HashSet(); + Set maps = new HashSet<>(); String propertyName = getValue(); for (PsiClass beanClass : beanClasses) { if (acceptSetters) { @@ -106,7 +108,7 @@ private Map> getAllSharedProperties(@Nonnull Collection> maps = new ArrayList>(); + List> maps = new ArrayList<>(); for (PsiClass beanClass : beanClasses) { maps.add(PropertyUtil.getAllProperties(beanClass, acceptSetters, acceptGetters)); } @@ -115,14 +117,17 @@ private Map> getAllSharedProperties(@Nonnull Collection> sharedProperties = getAllSharedProperties(descendants, true); - properties = new HashMap(); + properties = new HashMap<>(); for (Map.Entry> entry : sharedProperties.entrySet()) { String propertyName = entry.getKey(); PsiMethod firstMethod = entry.getValue().iterator().next(); @@ -190,19 +198,27 @@ public Object[] getVariants() { String propertyName = entry.getKey(); PsiType propertyType = PropertyUtil.getPropertyType(entry.getValue()); assert propertyType != null; - variants[i++] = LookupValueFactory.createLookupValueWithHint(propertyName, SpringIcons.SpringProperty, propertyType.getPresentableText()); + variants[i++] = LookupValueFactory.createLookupValueWithHint( + propertyName, + SpringImplIconGroup.springproperty(), + propertyType.getPresentableText() + ); } return variants; } + @Override + @RequiredWriteAction public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException { String name = PropertyUtil.getPropertyName(newElementName); return super.handleElementRename(name == null ? newElementName : name); } + @Override + @RequiredWriteAction public PsiElement bindToElement(@Nonnull PsiElement element) throws IncorrectOperationException { - if (element instanceof PsiMethod) { - String propertyName = PropertyUtil.getPropertyName((PsiMember)element); + if (element instanceof PsiMethod method) { + String propertyName = PropertyUtil.getPropertyName(method); if (propertyName != null) { return super.handleElementRename(propertyName); } @@ -213,7 +229,7 @@ public PsiElement bindToElement(@Nonnull PsiElement element) throws IncorrectOpe @Nonnull private static Set getUniqueBeanClasses(@Nonnull Collection beans) { if (beans.isEmpty()) return Collections.emptySet(); - Set classes = new HashSet(); + Set classes = new HashSet<>(); for (SpringBeanPointer bean : beans) { PsiClass psiClass = bean.getBeanClass(); if (psiClass != null) { @@ -225,12 +241,12 @@ private static Set getUniqueBeanClasses(@Nonnull Collection Map> reduce(@Nonnull Collection> maps) { - Map> intersection = new HashMap>(); + Map> intersection = new HashMap<>(); Iterator> i = maps.iterator(); if (i.hasNext()) { Map first = i.next(); for (Map.Entry entry : first.entrySet()) { - Set values = new HashSet(); + Set values = new HashSet<>(); values.add(entry.getValue()); intersection.put(entry.getKey(), values); } @@ -249,7 +265,7 @@ private static Map> reduce(@Nonnull Collection> maps) { @Nonnull @Override public LocalizeValue buildUnresolvedMessage(@Nonnull String s) { - return LocalizeValue.localizeTODO(SpringBundle.message("model.property.error.message", getValue())); + return SpringLocalize.modelPropertyErrorMessage(getValue()); } @Override diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReferenceSet.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReferenceSet.java index 85f8f6d7..bf07e48d 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReferenceSet.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/properties/PropertyReferenceSet.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.properties; import com.intellij.java.impl.psi.impl.beanProperties.BeanProperty; @@ -15,56 +14,59 @@ import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.List; /** * @author Dmitry Avdeev */ -public class PropertyReferenceSet extends ReferenceSetBase -{ - - @Nullable private final PsiClass myBeanClass; - - private final GenericDomValue> myGenericDomValue; - private final ConvertContext myContext; - private final CommonSpringBean myBean; +public class PropertyReferenceSet extends ReferenceSetBase { + @Nullable + private final PsiClass myBeanClass; - public PropertyReferenceSet(@Nonnull PsiElement element, - @Nullable PsiClass beanClass, - @Nonnull GenericDomValue> genericDomValue, - ConvertContext context, - CommonSpringBean bean) { - super(element); - myBeanClass = beanClass; - myGenericDomValue = genericDomValue; - myContext = context; - myBean = bean; - } + private final GenericDomValue> myGenericDomValue; + private final ConvertContext myContext; + private final CommonSpringBean myBean; - @Nonnull - protected PropertyReference createReference(TextRange range, int index) { - return new PropertyReference(this, range, index); - } + public PropertyReferenceSet( + @Nonnull PsiElement element, + @Nullable PsiClass beanClass, + @Nonnull GenericDomValue> genericDomValue, + ConvertContext context, + CommonSpringBean bean + ) { + super(element); + myBeanClass = beanClass; + myGenericDomValue = genericDomValue; + myContext = context; + myBean = bean; + } - public PropertyReference[] getPsiReferences() { - return getReferences().toArray(new PropertyReference[getReferences().size()]); - } + @Nonnull + @Override + protected PropertyReference createReference(TextRange range, int index) { + return new PropertyReference(this, range, index); + } - public GenericDomValue> getGenericDomValue() { - return myGenericDomValue; - } + @Override + public PropertyReference[] getPsiReferences() { + return getReferences().toArray(new PropertyReference[getReferences().size()]); + } - @Nullable - public PsiClass getBeanClass() { - return myBeanClass; - } + public GenericDomValue> getGenericDomValue() { + return myGenericDomValue; + } + @Nullable + public PsiClass getBeanClass() { + return myBeanClass; + } - public ConvertContext getContext() { - return myContext; - } + public ConvertContext getContext() { + return myContext; + } - public CommonSpringBean getBean() { - return myBean; - } + public CommonSpringBean getBean() { + return myBean; + } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropertyValueConverter.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropertyValueConverter.java index b301fd7c..8b44c9e4 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropertyValueConverter.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropertyValueConverter.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.values; import com.intellij.java.impl.util.xml.converters.values.GenericDomValueConvertersRegistry; @@ -27,7 +26,6 @@ * @author Dmitry Avdeev */ public class PropertyValueConverter extends WrappingConverter { - @Nonnull public List getValueTypes(GenericDomValue element) { if (element instanceof TypeHolder) { @@ -40,11 +38,12 @@ public List getValueTypes(GenericDomValue element) { } @Nonnull + @Override public List getConverters(@Nonnull GenericDomValue element) { XmlElement xmlElement = element.getXmlElement(); - if (xmlElement instanceof XmlAttribute) { - PsiLanguageInjectionHost host = (PsiLanguageInjectionHost)((XmlAttribute)xmlElement).getValueElement(); + if (xmlElement instanceof XmlAttribute attribute) { + PsiLanguageInjectionHost host = (PsiLanguageInjectionHost) attribute.getValueElement(); if (host == null || InjectedLanguageManager.getInstance(xmlElement.getProject()).getInjectedPsiFiles(xmlElement) != null) { return Collections.emptyList(); } @@ -52,7 +51,7 @@ public List getConverters(@Nonnull GenericDomValue element) { Project project = element.getManager().getProject(); GenericDomValueConvertersRegistry registry = SpringManager.getInstance(project).getValueProvidersRegistry(); List types = getValueTypes(element); - ArrayList list = new ArrayList(types.size()); + List list = new ArrayList<>(types.size()); if (types.isEmpty()) { Converter converter = registry.getConverter(element, null); if (converter != null) { @@ -70,6 +69,7 @@ public List getConverters(@Nonnull GenericDomValue element) { return list; } + @Override public Converter getConverter(@Nonnull GenericDomValue domElement) { List converters = getConverters(domElement); return converters.isEmpty() ? null : converters.get(0); diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropsValueConverter.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropsValueConverter.java index 3cd8426c..78ecb9ea 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropsValueConverter.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/PropsValueConverter.java @@ -5,13 +5,15 @@ import consulo.xml.dom.GenericDomValue; import jakarta.annotation.Nonnull; + import java.util.Collections; import java.util.List; public class PropsValueConverter extends PropertyValueConverter { - @Nonnull - public List getValueTypes(GenericDomValue domValue) { - PsiType type = SpringConverterUtil.findType(String.class, domValue.getManager().getProject()); - return type == null ? Collections.emptyList() : Collections.singletonList(type); - } + @Nonnull + @Override + public List getValueTypes(GenericDomValue domValue) { + PsiType type = SpringConverterUtil.findType(String.class, domValue.getManager().getProject()); + return type == null ? Collections.emptyList() : Collections.singletonList(type); + } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/PlaceholderPropertiesConverter.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/PlaceholderPropertiesConverter.java index 82e60623..41a43c32 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/PlaceholderPropertiesConverter.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/PlaceholderPropertiesConverter.java @@ -5,35 +5,36 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiReference; import consulo.util.lang.Pair; -import consulo.util.lang.function.Condition; import consulo.xml.dom.ConvertContext; import consulo.xml.dom.Converter; import consulo.xml.dom.CustomReferenceConverter; import consulo.xml.dom.GenericDomValue; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -public class PlaceholderPropertiesConverter extends Converter implements CustomReferenceConverter { +import java.util.function.Predicate; - public String fromString(@Nullable @NonNls String s, ConvertContext context) { +public class PlaceholderPropertiesConverter extends Converter implements CustomReferenceConverter { + @Override + public String fromString(@Nullable String s, ConvertContext context) { return s; } + @Override public String toString(@Nullable String s, ConvertContext context) { return s; } @Nonnull + @Override public PsiReference[] createReferences(GenericDomValue genericDomValue, PsiElement element, ConvertContext context) { return PlaceholderUtils.createPlaceholderPropertiesReferences(genericDomValue); } - public static class PlaceholderPropertiesCondition implements Condition> { - public boolean value(Pair pair) { + public static class PlaceholderPropertiesCondition implements Predicate> { + @Override + public boolean test(Pair pair) { return PlaceholderUtils.isPlaceholder(pair.getSecond()); } } - } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/ResourceValueConverter.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/ResourceValueConverter.java index 1bc4f093..3e9e955e 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/ResourceValueConverter.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/values/converters/ResourceValueConverter.java @@ -1,65 +1,61 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.ide.model.values.converters; import com.intellij.java.language.psi.PsiArrayType; import com.intellij.java.language.psi.PsiType; import com.intellij.spring.impl.ide.model.converters.ResourceResolverUtils; +import consulo.annotation.access.RequiredReadAction; import consulo.language.psi.ElementManipulators; import consulo.language.psi.PsiElement; -import consulo.language.psi.PsiFileSystemItem; import consulo.language.psi.PsiReference; import consulo.util.lang.Pair; import consulo.util.lang.StringUtil; -import consulo.util.lang.function.Condition; -import consulo.util.lang.function.PairProcessor; +import consulo.util.lang.function.Predicates; import consulo.xml.dom.ConvertContext; import consulo.xml.dom.Converter; import consulo.xml.dom.CustomReferenceConverter; import consulo.xml.dom.GenericDomValue; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -public class ResourceValueConverter extends Converter implements CustomReferenceConverter { +import java.util.*; +import java.util.function.Predicate; - public Object fromString(@Nullable @NonNls String s, ConvertContext context) { +public class ResourceValueConverter extends Converter implements CustomReferenceConverter { + @Override + @RequiredReadAction + public Object fromString(@Nullable String s, ConvertContext context) { GenericDomValue domValue = (GenericDomValue)context.getInvocationElement(); return StringUtil.isEmpty(s) - ? Collections.emptySet() - : ResourceResolverUtils.addResourceFilesFrom(domValue, s, new HashSet(), Condition.TRUE); + ? Collections.emptySet() + : ResourceResolverUtils.addResourceFilesFrom(domValue, s, new HashSet<>(), Predicates.alwaysTrue()); } + @Override public String toString(@Nullable Object o, ConvertContext context) { return null; } - @Nonnull - public PsiReference[] createReferences(GenericDomValue genericDomValue, final PsiElement element, ConvertContext context) { - final ArrayList result = new ArrayList(); - final int startInElement = ElementManipulators.getOffsetInElement(element); - ResourceResolverUtils.processSeparatedString(genericDomValue.getStringValue(), ",", new PairProcessor() { - public boolean process(String s, Integer offset) { - result.addAll(Arrays.asList(ResourceResolverUtils.getReferences(element, s, true, false, offset + startInElement, true))); - return true; - } + @Override + public PsiReference[] createReferences(GenericDomValue genericDomValue, PsiElement element, ConvertContext context) { + List result = new ArrayList<>(); + int startInElement = ElementManipulators.getOffsetInElement(element); + ResourceResolverUtils.processSeparatedString(genericDomValue.getStringValue(), ",", (s, offset) -> { + result.addAll(Arrays.asList(ResourceResolverUtils.getReferences(element, s, true, false, offset + startInElement, true))); + return true; }); return result.isEmpty() ? PsiReference.EMPTY_ARRAY : result.toArray(new PsiReference[result.size()]); } - public static class ResourceValueConverterCondition implements Condition> { - public boolean value(Pair pair) { + public static class ResourceValueConverterCondition implements Predicate> { + @Override + public boolean test(Pair pair) { PsiType psiType = pair.getFirst(); - if (psiType instanceof PsiArrayType) { - psiType = ((PsiArrayType)psiType).getComponentType(); + if (psiType instanceof PsiArrayType arrayType) { + psiType = arrayType.getComponentType(); } return psiType != null && "org.springframework.core.io.Resource".equals(psiType.getCanonicalText()); } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/QualifierAttribute.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/QualifierAttribute.java index a02b6b31..3b86189b 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/QualifierAttribute.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/QualifierAttribute.java @@ -1,31 +1,32 @@ package com.intellij.spring.impl.ide.model.xml; -import consulo.util.lang.Comparing; import consulo.util.collection.HashingStrategy; - +import consulo.util.lang.Comparing; import jakarta.annotation.Nullable; +import java.util.Objects; + /** * @author Dmitry Avdeev */ public interface QualifierAttribute { - @Nullable String getAttributeKey(); @Nullable String getAttributeValue(); - HashingStrategy HASHING_STRATEGY = new HashingStrategy() { - + HashingStrategy HASHING_STRATEGY = new HashingStrategy<>() { + @Override public int hashCode(QualifierAttribute object) { String key = object.getAttributeKey(); String value = object.getAttributeValue(); return (key == null ? 0 : key.hashCode()) + (value == null ? 0 : value.hashCode()); } + @Override public boolean equals(QualifierAttribute o1, QualifierAttribute o2) { - return Comparing.equal(o1.getAttributeKey(), o2.getAttributeKey()) && Comparing.equal(o1.getAttributeValue(), o2.getAttributeValue()); + return Objects.equals(o1.getAttributeKey(), o2.getAttributeKey()) && Objects.equals(o1.getAttributeValue(), o2.getAttributeValue()); } }; } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutExpressionConverter.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutExpressionConverter.java index 625534e9..17467227 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutExpressionConverter.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutExpressionConverter.java @@ -5,24 +5,26 @@ import com.intellij.aop.psi.AopPointcutExpressionFile; import com.intellij.aop.psi.PsiPointcutExpression; +import consulo.annotation.access.RequiredReadAction; import consulo.document.util.TextRange; import consulo.language.inject.InjectedLanguageManager; import consulo.language.psi.PsiElement; import consulo.util.lang.Pair; -import consulo.xml.language.psi.XmlAttributeValue; import consulo.xml.dom.ConvertContext; import consulo.xml.dom.Converter; import consulo.xml.dom.GenericAttributeValue; -import org.jetbrains.annotations.NonNls; - +import consulo.xml.language.psi.XmlAttributeValue; import jakarta.annotation.Nullable; + import java.util.List; /** * @author peter */ public class PointcutExpressionConverter extends Converter { - public PsiPointcutExpression fromString(@Nullable @NonNls String s, ConvertContext context) { + @Override + @RequiredReadAction + public PsiPointcutExpression fromString(@Nullable String s, ConvertContext context) { XmlAttributeValue attributeValue = ((GenericAttributeValue)context.getInvocationElement()).getXmlAttributeValue(); if (attributeValue == null) return null; @@ -36,6 +38,7 @@ public String getErrorMessage(@Nullable String s, ConvertContext context) { return null; } + @Override public String toString(@Nullable PsiPointcutExpression psiPointcutExpression, ConvertContext context) { throw new UnsupportedOperationException("Method toString is not yet implemented in " + getClass().getName()); } diff --git a/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutType.java b/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutType.java index ca60cc75..12b0b8e0 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutType.java +++ b/plugin/src/main/java/com/intellij/spring/impl/ide/model/xml/aop/PointcutType.java @@ -1,17 +1,22 @@ // Generated on Thu Nov 09 17:15:14 MSK 2006 // DTD/Schema : http://www.springframework.org/schema/aop - package com.intellij.spring.impl.ide.model.xml.aop; /** * http://www.springframework.org/schema/aop:typeAttrType enumeration. */ public enum PointcutType implements consulo.xml.dom.NamedEnum { - ASPECTJ ("aspectj"), - REGEX ("regex"); + ASPECTJ("aspectj"), + REGEX("regex"); + + private final String value; - private final String value; - private PointcutType(String value) { this.value = value; } - public String getValue() { return value; } + private PointcutType(String value) { + this.value = value; + } + @Override + public String getValue() { + return value; + } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/aop/psi/PsiBeanPointcutExpression.java b/plugin/src/main/java/com/intellij/spring/impl/model/aop/psi/PsiBeanPointcutExpression.java index 0ee1f024..71f05f6e 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/aop/psi/PsiBeanPointcutExpression.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/aop/psi/PsiBeanPointcutExpression.java @@ -1,19 +1,18 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.model.aop.psi; import com.intellij.aop.AopAdvisedElementsSearcher; import com.intellij.aop.psi.*; import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiMember; -import com.intellij.spring.impl.ide.SpringIcons; import com.intellij.spring.impl.ide.SpringModel; import com.intellij.spring.impl.ide.aop.SpringAdvisedElementsSearcher; import com.intellij.spring.impl.ide.model.SpringUtils; import com.intellij.spring.impl.ide.model.xml.beans.SpringBaseBeanPointer; -import consulo.application.util.function.Processor; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.document.util.TextRange; import consulo.language.ast.ASTNode; import consulo.language.editor.completion.lookup.LookupElement; @@ -23,41 +22,46 @@ import consulo.language.psi.PsiReference; import consulo.language.psi.PsiReferenceBase; import consulo.language.util.IncorrectOperationException; -import consulo.language.util.ModuleUtilCore; import consulo.module.Module; +import consulo.spring.impl.icon.SpringImplIconGroup; import consulo.util.lang.StringUtil; -import consulo.util.lang.ref.Ref; +import consulo.util.lang.ref.SimpleReference; import jakarta.annotation.Nonnull; + import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; +import java.util.function.Predicate; import java.util.regex.Pattern; /** * @author peter */ public class PsiBeanPointcutExpression extends AopElementBase implements PsiPointcutExpression { - public PsiBeanPointcutExpression(@Nonnull ASTNode node) { super(node); } + @Override public String toString() { return "PsiBeanPointcutExpression"; } @Nonnull + @Override + @RequiredReadAction public PointcutMatchDegree acceptsSubject(PointcutContext context, PsiMember member) { - return acceptsClass(member instanceof PsiClass ? (PsiClass)member : member.getContainingClass()); + return acceptsClass(member instanceof PsiClass psiClass ? psiClass : member.getContainingClass()); } + @RequiredReadAction private PointcutMatchDegree acceptsClass(PsiClass psiClass) { PsiReference reference = getReference(); if (reference == null) return PointcutMatchDegree.FALSE; - Module module = ModuleUtilCore.findModuleForPsiElement(psiClass); + Module module = psiClass.getModule(); if (module == null) return PointcutMatchDegree.FALSE; Pattern pattern = Pattern.compile(reference.getCanonicalText().replaceAll(" ", "").replaceAll("\\*", "\\.\\*")); @@ -75,6 +79,7 @@ private PointcutMatchDegree acceptsClass(PsiClass psiClass) { } @Override + @RequiredReadAction public PsiReference getReference() { String s = getText(); final int start = s.indexOf('('); @@ -82,27 +87,26 @@ public PsiReference getReference() { int end = s.indexOf(')'); if (end < 0) end = s.length(); - return new PsiReferenceBase(this, new TextRange(start + 1, end), true) { + return new PsiReferenceBase<>(this, new TextRange(start + 1, end), true) { + @Override + @RequiredReadAction public PsiElement resolve() { - final Ref bean = Ref.create(null); - processBeans(new Processor() { - public boolean process(SpringBaseBeanPointer s) { - if (getCanonicalText().equals(s.getName())) { - bean.set(s.getSpringBean().getIdentifyingPsiElement()); - return false; - } - return true; + SimpleReference bean = SimpleReference.create(null); + processBeans(s1 -> { + if (getCanonicalText().equals(s1.getName())) { + bean.set(s1.getSpringBean().getIdentifyingPsiElement()); + return false; } + return true; }); return bean.get(); } @Override + @RequiredWriteAction public PsiElement handleElementRename(String newText) throws IncorrectOperationException { AopPointcutExpressionFile file = (AopPointcutExpressionFile)PsiFileFactory.getInstance(getProject()) - .createFileFromText("a", - AopPointcutExpressionFileType.INSTANCE, - "bean(" + newText + ")"); + .createFileFromText("a", AopPointcutExpressionFileType.INSTANCE, "bean(" + newText + ")"); PsiBeanPointcutExpression pointcutExpression = (PsiBeanPointcutExpression)file.getPointcutExpression(); assert pointcutExpression != null; ASTNode parent = getNode().getTreeParent(); @@ -112,37 +116,36 @@ public PsiElement handleElementRename(String newText) throws IncorrectOperationE return node.getPsi(); } + @Override + @RequiredReadAction public Object[] getVariants() { - final List result = new ArrayList(); - processBeans(new Processor() { - public boolean process(SpringBaseBeanPointer bean) { - String name = bean.getName(); - if (name != null && name.indexOf('#') < 0) { - result.add(LookupElementBuilder.create(name).withIcon(SpringIcons.SPRING_BEAN_ICON)); - } - return true; + List result = new ArrayList<>(); + processBeans(bean -> { + String name = bean.getName(); + if (name != null && name.indexOf('#') < 0) { + result.add(LookupElementBuilder.create(name).withIcon(SpringImplIconGroup.springbean())); } + return true; }); return result.toArray(); } }; } - private boolean processBeans(Processor processor) { + private boolean processBeans(Predicate processor) { AopAdvisedElementsSearcher searcher = getContainingFile().getAopModel().getAdvisedElementsSearcher(); - if (!(searcher instanceof SpringAdvisedElementsSearcher)) return true; - for (SpringModel model : ((SpringAdvisedElementsSearcher)searcher).getSpringModels()) { + if (!(searcher instanceof SpringAdvisedElementsSearcher advisedElementsSearcher)) return true; + for (SpringModel model : advisedElementsSearcher.getSpringModels()) { for (SpringBaseBeanPointer pointer : model.getAllCommonBeans(true)) { - if (!processor.process(pointer)) return false; - + if (!processor.test(pointer)) return false; } } return true; } @Nonnull + @Override public Collection getPatterns() { return Collections.emptyList(); } - } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceRefValueImpl.java b/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceRefValueImpl.java index 17559441..95fc4b6e 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceRefValueImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceRefValueImpl.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.model.beans; import com.intellij.java.language.psi.PsiType; @@ -12,37 +11,41 @@ import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.List; /** * @author peter */ public abstract class PNamespaceRefValueImpl implements PNamespaceRefValue { - - @Nonnull - public List getRequiredTypes() { - return PNamespaceValueImpl.getPropertyType(this, getPropertyName()); - } - - @Nonnull - @NonNls - public String getPropertyName() { - String name = getXmlElementName(); - return name.substring(0, name.length() - "-ref".length()); - } - - @Nullable - public PsiType[] getTypesByValue() { - return null; - } - - @Nonnull - public GenericDomValue getRefElement() { - return this; - } - - @Nonnull - public GenericDomValue getValueElement() { - return getParent().getGenericInfo().getAttributeChildDescription(getPropertyName()).getDomAttributeValue(getParent()); - } -} \ No newline at end of file + @Nonnull + @Override + public List getRequiredTypes() { + return PNamespaceValueImpl.getPropertyType(this, getPropertyName()); + } + + @Nonnull + @Override + public String getPropertyName() { + String name = getXmlElementName(); + return name.substring(0, name.length() - "-ref".length()); + } + + @Nullable + @Override + public PsiType[] getTypesByValue() { + return null; + } + + @Nonnull + @Override + public GenericDomValue getRefElement() { + return this; + } + + @Nonnull + @Override + public GenericDomValue getValueElement() { + return getParent().getGenericInfo().getAttributeChildDescription(getPropertyName()).getDomAttributeValue(getParent()); + } +} diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceValueImpl.java b/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceValueImpl.java index 68f50cb6..705f1eaa 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceValueImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/beans/PNamespaceValueImpl.java @@ -13,10 +13,9 @@ import consulo.util.collection.ContainerUtil; import consulo.xml.dom.DomElement; import consulo.xml.dom.GenericDomValue; -import org.jetbrains.annotations.NonNls; - import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Collections; import java.util.List; @@ -24,41 +23,44 @@ * @author peter */ public abstract class PNamespaceValueImpl implements PNamespaceValue { - @Nonnull + @Override public List getRequiredTypes() { return getPropertyType(this, getPropertyName()); } @Nonnull - static List getPropertyType(DomElement value, @Nonnull @NonNls String name) { + static List getPropertyType(DomElement value, @Nonnull String name) { SpringBean bean = (SpringBean)value.getParent(); assert bean != null; PsiClass beanClass = bean.getBeanClass(); if (beanClass != null) { List methods = PropertyUtil.getSetters(beanClass, name); - return ContainerUtil.map2List(methods, psiMethod -> PropertyUtil.getPropertyType(psiMethod)); + return ContainerUtil.map2List(methods, PropertyUtil::getPropertyType); } return Collections.emptyList(); } @Nonnull - @NonNls + @Override public String getPropertyName() { return getXmlElementName(); } @Nullable + @Override public PsiType[] getTypesByValue() { return null; } @Nonnull + @Override public GenericDomValue getRefElement() { return getParent().getGenericInfo().getAttributeChildDescription(getPropertyName() + "-ref").getDomAttributeValue(getParent()); } @Nonnull + @Override public GenericDomValue getValueElement() { return this; } diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/beans/ReplacedMethodImpl.java b/plugin/src/main/java/com/intellij/spring/impl/model/beans/ReplacedMethodImpl.java index 5ab97227..87f64aaf 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/beans/ReplacedMethodImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/beans/ReplacedMethodImpl.java @@ -8,14 +8,15 @@ */ @SuppressWarnings({"AbstractClassNeverImplemented"}) public abstract class ReplacedMethodImpl implements ReplacedMethod { + @Override + public int hashCode() { + String value = getName().getStringValue(); + return value == null ? 0 : value.hashCode(); + } - public int hashCode() { - String value = getName().getStringValue(); - return value == null ? 0 : value.hashCode(); - } - - public boolean equals(Object obj) { - return obj instanceof ReplacedMethod && - ComparatorUtil.equalsNullable(getName().getStringValue(), ((ReplacedMethod)obj).getName().getStringValue()); - } + @Override + public boolean equals(Object obj) { + return obj instanceof ReplacedMethod replacedMethod + && ComparatorUtil.equalsNullable(getName().getStringValue(), replacedMethod.getName().getStringValue()); + } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/beans/ResolvedConstructorArgsImpl.java b/plugin/src/main/java/com/intellij/spring/impl/model/beans/ResolvedConstructorArgsImpl.java index e84ecbe8..bf1e6243 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/beans/ResolvedConstructorArgsImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/beans/ResolvedConstructorArgsImpl.java @@ -1,7 +1,6 @@ /* * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved. */ - package com.intellij.spring.impl.model.beans; import com.intellij.java.language.psi.*; @@ -24,34 +23,27 @@ */ @SuppressWarnings({"UnnecessaryFullyQualifiedName"}) class ResolvedConstructorArgsImpl implements ResolvedConstructorArgs { - /** * @see org.springframework.beans.factory.support.AutowireUtils#sortConstructors(java.lang.reflect.Constructor[]) */ - private static final Comparator CTOR_COMPARATOR = new Comparator() { - public int compare(PsiMethod o1, PsiMethod o2) { - boolean p1 = o1.hasModifierProperty(PsiModifier.PUBLIC); - boolean p2 = o2.hasModifierProperty(PsiModifier.PUBLIC); - if (p1 != p2) { - return (p1 ? -1 : 1); - } - return o1.getParameterList().getParametersCount() - o2.getParameterList().getParametersCount(); + private static final Comparator CTOR_COMPARATOR = (o1, o2) -> { + boolean p1 = o1.isPublic(); + boolean p2 = o2.isPublic(); + if (p1 != p2) { + return (p1 ? -1 : 1); } + return o1.getParameterList().getParametersCount() - o2.getParameterList().getParametersCount(); }; - private static final Comparator ARG_COMPARATOR = new Comparator() { - public int compare(ConstructorArg o1, ConstructorArg o2) { - boolean hasValue1 = DomUtil.hasXml(o1.getValueElement()); - boolean hasValue2 = DomUtil.hasXml(o2.getValueElement()); - return hasValue1 ? (hasValue2 ? 0 : 1) : (hasValue2 ? -1 : 0); - } + private static final Comparator ARG_COMPARATOR = (o1, o2) -> { + boolean hasValue1 = DomUtil.hasXml(o1.getValueElement()); + boolean hasValue2 = DomUtil.hasXml(o2.getValueElement()); + return hasValue1 ? (hasValue2 ? 0 : 1) : (hasValue2 ? -1 : 0); }; @Nullable private PsiMethod myResolvedMethod; - private final Map> myResolvedArgs = - new HashMap>(); - private final Map>> myAutowiredParams = - new HashMap>>(); + private final Map> myResolvedArgs = new HashMap<>(); + private final Map>> myAutowiredParams = new HashMap<>(); private final boolean myResolved; private List myCheckedMethods; @@ -60,29 +52,35 @@ public int compare(ConstructorArg o1, ConstructorArg o2) { myResolved = resolve(bean, SpringUtils.getSpringModel(bean)); } + @Override public boolean isResolved() { return myResolved; } @Nullable + @Override public PsiMethod getResolvedMethod() { return myResolvedMethod; } @Nullable + @Override public List getCheckedMethods() { return myCheckedMethods; } @Nullable + @Override public Map getResolvedArgs() { return myResolvedMethod == null ? null : getResolvedArgs(myResolvedMethod); } + @Override public Map getResolvedArgs(@Nonnull PsiMethod method) { return myResolvedArgs.get(method); } + @Override public Map> getAutowiredParams(@Nonnull PsiMethod method) { return myAutowiredParams.get(method); } @@ -117,7 +115,7 @@ private boolean resolve(SpringBean bean, SpringModel springModel) { } // there is at least one candidate here - myCheckedMethods = new ArrayList(methods.size()); + myCheckedMethods = new ArrayList<>(methods.size()); Set args = bean.getAllConstructorArgs(); boolean constructorAutowire = SpringAutowireUtil.isConstructorAutowire(bean); @@ -130,11 +128,11 @@ private boolean resolve(SpringBean bean, SpringModel springModel) { if (myResolvedMethod != null && params.length < myResolvedMethod.getParameterList().getParametersCount()) { return true; } - HashMap resolvedArgs = new HashMap(params.length); + Map resolvedArgs = new HashMap<>(params.length); myResolvedArgs.put(method, resolvedArgs); - HashMap> autowiredParams = new HashMap>(); + Map> autowiredParams = new HashMap<>(); myAutowiredParams.put(method, autowiredParams); - Set usedArgs = new HashSet(args.size()); + Set usedArgs = new HashSet<>(args.size()); int autowired = 0; for (int i = 0; i < params.length; i++) { PsiParameter param = params[i]; @@ -167,15 +165,15 @@ private static class ConstructorArgumentValues { List genericArgs; private int init(Set args) { - indexedArgs = new HashMap(args.size()); - genericArgs = new ArrayList(args.size()); + indexedArgs = new HashMap<>(args.size()); + genericArgs = new ArrayList<>(args.size()); int minNrOfArgs = args.size(); for (ConstructorArg arg : args) { Integer index = arg.getIndex().getValue(); if (index != null) { indexedArgs.put(index, arg); - minNrOfArgs = Math.max(minNrOfArgs, index.intValue()); + minNrOfArgs = Math.max(minNrOfArgs, index); } else { genericArgs.add(arg); diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/context/PropertyPlaceholderImpl.java b/plugin/src/main/java/com/intellij/spring/impl/model/context/PropertyPlaceholderImpl.java index ab68818c..f9f6ee57 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/context/PropertyPlaceholderImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/context/PropertyPlaceholderImpl.java @@ -6,9 +6,9 @@ import jakarta.annotation.Nonnull; public abstract class PropertyPlaceholderImpl extends DomSpringBeanImpl implements PropertyPlaceholder { - - @Nonnull - public String getClassName() { - return PlaceholderUtils.PLACEHOLDER_CONFIGURER_CLASS; - } + @Nonnull + @Override + public String getClassName() { + return PlaceholderUtils.PLACEHOLDER_CONFIGURER_CLASS; + } } diff --git a/plugin/src/main/java/com/intellij/spring/impl/model/jee/RemoteSlsbImpl.java b/plugin/src/main/java/com/intellij/spring/impl/model/jee/RemoteSlsbImpl.java index a30bc218..462dd31e 100644 --- a/plugin/src/main/java/com/intellij/spring/impl/model/jee/RemoteSlsbImpl.java +++ b/plugin/src/main/java/com/intellij/spring/impl/model/jee/RemoteSlsbImpl.java @@ -6,9 +6,9 @@ import com.intellij.spring.impl.ide.model.xml.jee.RemoteSlsb; public abstract class RemoteSlsbImpl extends DomSpringBeanImpl implements RemoteSlsb { - - @Nonnull - public String getClassName() { - return "org.springframework.ejb.access.SimpleRemoteStatelessSessionProxyFactoryBean"; - } + @Nonnull + @Override + public String getClassName() { + return "org.springframework.ejb.access.SimpleRemoteStatelessSessionProxyFactoryBean"; + } } \ No newline at end of file