diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index ca879973..7d3f916c 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -8,7 +8,6 @@ jobs: fail-fast: false matrix: version: - - { jdk: 11, idea: 2022.1 } - { jdk: 17, idea: 2022.2 } - { jdk: 17, idea: 2022.3 } - { jdk: 17, idea: 2023.1 } diff --git a/build.gradle b/build.gradle index adc4621e..706a9062 100644 --- a/build.gradle +++ b/build.gradle @@ -18,8 +18,8 @@ apply plugin: 'license' apply plugin: 'checkstyle' apply plugin: 'jacoco' -sourceCompatibility = 11 -targetCompatibility = 11 +sourceCompatibility = 17 +targetCompatibility = 17 repositories { mavenLocal() diff --git a/gradle.properties b/gradle.properties index 2b4ca168..b3b2480c 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,7 +2,7 @@ # https://www.jetbrains.com/intellij-repository/releases # https://www.jetbrains.com/intellij-repository/snapshots -ideaVersion = 2022.1 +ideaVersion = 2022.2 ideaType = IC sources = true isEAP = false diff --git a/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructBaseReference.java b/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructBaseReference.java index b2e93288..330368ce 100644 --- a/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructBaseReference.java +++ b/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructBaseReference.java @@ -170,8 +170,8 @@ static PsiReference[] create(PsiElement psiEl ReferenceCreator creator, boolean supportsNested) { String targetValue; Function rangeCreator; - if ( psiElement instanceof PsiReferenceExpression ) { - PsiElement resolvedPsiElement = ( (PsiReferenceExpression) psiElement ).resolve(); + if ( psiElement instanceof PsiReferenceExpression psiReferenceExpression ) { + PsiElement resolvedPsiElement = psiReferenceExpression.resolve(); PsiLiteralExpression expression = PsiTreeUtil.findChildOfType( resolvedPsiElement, diff --git a/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructSourceReference.java b/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructSourceReference.java index 901f6c0f..1a7f27be 100644 --- a/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructSourceReference.java +++ b/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructSourceReference.java @@ -125,17 +125,17 @@ Object[] getVariantsInternal(@NotNull PsiMethod mappingMethod) { PsiType resolvedType() { PsiElement element = resolve(); - if ( element instanceof PsiMethod ) { - return ( (PsiMethod) element ).getReturnType(); + if ( element instanceof PsiMethod psiMethod ) { + return psiMethod.getReturnType(); } - else if ( element instanceof PsiParameter ) { - return ( (PsiParameter) element ).getType(); + else if ( element instanceof PsiParameter psiParameter ) { + return psiParameter.getType(); } - else if ( element instanceof PsiRecordComponent ) { - return ( (PsiRecordComponent) element ).getType(); + else if ( element instanceof PsiRecordComponent psiRecordComponent ) { + return psiRecordComponent.getType(); } - else if ( element instanceof PsiField ) { - return ( (PsiField) element ).getType(); + else if ( element instanceof PsiField psiField ) { + return psiField.getType(); } return null; @@ -160,11 +160,11 @@ static PsiReference[] createNonNested(PsiElement psiElement) { } private static PsiType memberPsiType(PsiElement psiMember) { - if ( psiMember instanceof PsiMethod ) { - return ( (PsiMethod) psiMember ).getReturnType(); + if ( psiMember instanceof PsiMethod psiMemberMethod ) { + return psiMemberMethod.getReturnType(); } - else if ( psiMember instanceof PsiVariable ) { - return ( (PsiVariable) psiMember ).getType(); + else if ( psiMember instanceof PsiVariable psiMemberVariable ) { + return psiMemberVariable.getType(); } else { return null; diff --git a/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructTargetReference.java b/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructTargetReference.java index e5d89f5c..c4cc4fd6 100644 --- a/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructTargetReference.java +++ b/src/main/java/org/mapstruct/intellij/codeinsight/references/MapstructTargetReference.java @@ -191,17 +191,17 @@ Object[] getVariantsInternal(@NotNull PsiMethod mappingMethod) { PsiType resolvedType() { PsiElement element = resolve(); - if ( element instanceof PsiMethod ) { - return firstParameterPsiType( (PsiMethod) element ); + if ( element instanceof PsiMethod psiMethod ) { + return firstParameterPsiType( psiMethod ); } - else if ( element instanceof PsiParameter ) { - return ( (PsiParameter) element ).getType(); + else if ( element instanceof PsiParameter psiParameter ) { + return psiParameter.getType(); } - else if ( element instanceof PsiRecordComponent ) { - return ( (PsiRecordComponent) element ).getType(); + else if ( element instanceof PsiRecordComponent psiRecordComponent ) { + return psiRecordComponent.getType(); } - else if ( element instanceof PsiField ) { - return ( (PsiField) element ).getType(); + else if ( element instanceof PsiField psiField ) { + return psiField.getType(); } return null; @@ -217,11 +217,11 @@ static PsiReference[] create(PsiElement psiElement) { } private static PsiType memberPsiType(PsiElement psiMember) { - if ( psiMember instanceof PsiMethod ) { - return firstParameterPsiType( (PsiMethod) psiMember ); + if ( psiMember instanceof PsiMethod psiMemberMethod ) { + return firstParameterPsiType( psiMemberMethod ); } - else if ( psiMember instanceof PsiVariable ) { - return ( (PsiVariable) psiMember ).getType(); + else if ( psiMember instanceof PsiVariable psiMemberVariable ) { + return psiMemberVariable.getType(); } else { return null; diff --git a/src/main/java/org/mapstruct/intellij/expression/JavaExpressionInjector.java b/src/main/java/org/mapstruct/intellij/expression/JavaExpressionInjector.java index 04690657..75eb0821 100644 --- a/src/main/java/org/mapstruct/intellij/expression/JavaExpressionInjector.java +++ b/src/main/java/org/mapstruct/intellij/expression/JavaExpressionInjector.java @@ -70,11 +70,10 @@ private void importIfNecessary(PsiClass cls, @NotNull Set imports) { private void appendType(@NotNull StringBuilder sb, @NotNull Set imports, @NotNull PsiType type) { importIfNecessary( PsiUtil.resolveClassInType( type ), imports ); - if ( !( type instanceof PsiClassType ) ) { + if ( !( type instanceof PsiClassType ct ) ) { sb.append( type.getPresentableText() ); return; } - PsiClassType ct = (PsiClassType) type; sb.append( ct.getName() ); PsiType[] typeParameters = ct.getParameters(); if ( typeParameters.length == 0 ) { @@ -178,18 +177,18 @@ public void getLanguagesToInject(@NotNull MultiHostRegistrar registrar, @NotNull attributeValue ); if ( references.length > 0 ) { PsiElement resolved = references[0].resolve(); - if ( resolved instanceof PsiMethod ) { + if ( resolved instanceof PsiMethod resolvedPsiMethod ) { PsiParameter[] psiParameters = - ((PsiMethod) resolved).getParameterList().getParameters(); + resolvedPsiMethod.getParameterList().getParameters(); if ( psiParameters.length > 0) { targetType = psiParameters[0].getType(); } } - else if ( resolved instanceof PsiParameter ) { - targetType = ( (PsiParameter) resolved ).getType(); + else if ( resolved instanceof PsiParameter resolvedPsiParameter ) { + targetType = resolvedPsiParameter.getType(); } - else if ( resolved instanceof PsiField) { - targetType = ( (PsiField) resolved ).getType(); + else if ( resolved instanceof PsiField resolvedPsiField ) { + targetType = resolvedPsiField.getType(); } } } @@ -259,12 +258,13 @@ else if ( resolved instanceof PsiField) { for ( PsiAnnotationMemberValue importValue : AnnotationUtil.arrayAttributeValues( attribute.getValue() ) ) { - if ( importValue instanceof PsiJavaCodeReferenceElement ) { - imports.add( ( (PsiJavaCodeReferenceElement) importValue ).getQualifiedName() ); + if ( importValue instanceof PsiJavaCodeReferenceElement importJavaCodeReferenceElement ) { + imports.add( importJavaCodeReferenceElement.getQualifiedName() ); } - else if ( importValue instanceof PsiClassObjectAccessExpression ) { + else if ( importValue instanceof PsiClassObjectAccessExpression + importClassObjectAccessExpression ) { PsiJavaCodeReferenceElement referenceElement = - ( (PsiClassObjectAccessExpression) importValue ).getOperand() + importClassObjectAccessExpression.getOperand() .getInnermostComponentReferenceElement(); if ( referenceElement != null ) { imports.add( referenceElement.getQualifiedName() ); diff --git a/src/main/java/org/mapstruct/intellij/inspection/FromMapMappingMapTypeInspection.java b/src/main/java/org/mapstruct/intellij/inspection/FromMapMappingMapTypeInspection.java index e72f7f8f..4ada55ed 100644 --- a/src/main/java/org/mapstruct/intellij/inspection/FromMapMappingMapTypeInspection.java +++ b/src/main/java/org/mapstruct/intellij/inspection/FromMapMappingMapTypeInspection.java @@ -133,8 +133,7 @@ public boolean isAvailable(@NotNull Project project, @NotNull PsiFile file, if (!super.isAvailable( project, file, startElement, endElement ) ) { return false; } - if (startElement instanceof PsiParameter) { - PsiParameter parameter = (PsiParameter) startElement; + if (startElement instanceof PsiParameter parameter) { PsiType[] parameters = getGenericTypes( parameter ); return parameters != null && parameters.length == 0; } @@ -179,8 +178,7 @@ public boolean isAvailable(@NotNull Project project, @NotNull PsiFile file, if (!super.isAvailable( project, file, startElement, endElement ) ) { return false; } - if (startElement instanceof PsiParameter) { - PsiParameter parameter = (PsiParameter) startElement; + if (startElement instanceof PsiParameter parameter) { PsiType[] parameters = getGenericTypes( parameter ); if (parameters == null || parameters.length != 2) { return false; diff --git a/src/main/java/org/mapstruct/intellij/inspection/JavaExpressionUnnecessaryWhitespacesInspector.java b/src/main/java/org/mapstruct/intellij/inspection/JavaExpressionUnnecessaryWhitespacesInspector.java index c91830f4..b5627404 100644 --- a/src/main/java/org/mapstruct/intellij/inspection/JavaExpressionUnnecessaryWhitespacesInspector.java +++ b/src/main/java/org/mapstruct/intellij/inspection/JavaExpressionUnnecessaryWhitespacesInspector.java @@ -80,8 +80,7 @@ private RemoveWhitespacesBefore(@NotNull PsiNameValuePair element) { @Override public void invoke(@NotNull Project project, @NotNull PsiFile psiFile, @NotNull PsiElement psiElement, @NotNull PsiElement psiElement1) { - if (psiElement instanceof PsiNameValuePair) { - PsiNameValuePair psiNameValuePair = (PsiNameValuePair) psiElement; + if (psiElement instanceof PsiNameValuePair psiNameValuePair) { PsiAnnotationMemberValue value = psiNameValuePair.getValue(); if (value != null) { String text = value.getText(); @@ -102,10 +101,10 @@ public boolean isAvailable(@NotNull Project project, @NotNull PsiFile file, @Not if ( !super.isAvailable( project, file, startElement, endElement ) ) { return false; } - if ( !(startElement instanceof PsiNameValuePair ) ) { + if ( !(startElement instanceof PsiNameValuePair startPsiNameValuePair ) ) { return false; } - return ((PsiNameValuePair) startElement).getValue() != null; + return startPsiNameValuePair.getValue() != null; } } @@ -126,8 +125,7 @@ private RemoveWhitespacesAfter(@NotNull PsiNameValuePair element) { @Override public void invoke(@NotNull Project project, @NotNull PsiFile psiFile, @NotNull PsiElement psiElement, @NotNull PsiElement psiElement1) { - if (psiElement instanceof PsiNameValuePair) { - PsiNameValuePair psiNameValuePair = (PsiNameValuePair) psiElement; + if (psiElement instanceof PsiNameValuePair psiNameValuePair) { PsiAnnotationMemberValue value = psiNameValuePair.getValue(); if (value != null) { String text = value.getText(); @@ -148,10 +146,10 @@ public boolean isAvailable(@NotNull Project project, @NotNull PsiFile file, @Not if ( !super.isAvailable( project, file, startElement, endElement ) ) { return false; } - if ( !(startElement instanceof PsiNameValuePair ) ) { + if ( !(startElement instanceof PsiNameValuePair startPsiNameValuePair ) ) { return false; } - return ((PsiNameValuePair) startElement).getValue() != null; + return startPsiNameValuePair.getValue() != null; } } } diff --git a/src/main/java/org/mapstruct/intellij/inspection/MappingAnnotationInspectionBase.java b/src/main/java/org/mapstruct/intellij/inspection/MappingAnnotationInspectionBase.java index 54740b74..ed971afe 100644 --- a/src/main/java/org/mapstruct/intellij/inspection/MappingAnnotationInspectionBase.java +++ b/src/main/java/org/mapstruct/intellij/inspection/MappingAnnotationInspectionBase.java @@ -44,9 +44,8 @@ public void visitAnnotation(@NotNull PsiAnnotation annotation ) { MappingAnnotation mappingAnnotation = new MappingAnnotation(); for (JvmAnnotationAttribute annotationAttribute : annotation.getAttributes()) { // exclude not written attributes. They result in a syntax error - if (annotationAttribute instanceof PsiNameValuePair + if (annotationAttribute instanceof PsiNameValuePair nameValuePair && annotationAttribute.getAttributeValue() != null) { - PsiNameValuePair nameValuePair = (PsiNameValuePair) annotationAttribute; switch (nameValuePair.getAttributeName()) { case "target" : mappingAnnotation.setTargetProperty( nameValuePair ); @@ -285,8 +284,7 @@ public boolean isAvailable( @NotNull Project project, @NotNull PsiFile file, @No @Override public void invoke( @NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement, @NotNull PsiElement endElement ) { - if (endElement instanceof PsiNameValuePair) { - PsiNameValuePair end = (PsiNameValuePair) endElement; + if (endElement instanceof PsiNameValuePair end) { PsiAnnotationParamListImpl parent = (PsiAnnotationParamListImpl) end.getParent(); PsiElement parent1 = parent.getParent(); diff --git a/src/main/java/org/mapstruct/intellij/inspection/WrongUsageOfMappersFactoryInspection.java b/src/main/java/org/mapstruct/intellij/inspection/WrongUsageOfMappersFactoryInspection.java index 94b76912..b2e461b1 100644 --- a/src/main/java/org/mapstruct/intellij/inspection/WrongUsageOfMappersFactoryInspection.java +++ b/src/main/java/org/mapstruct/intellij/inspection/WrongUsageOfMappersFactoryInspection.java @@ -66,10 +66,9 @@ public void visitMethodCallExpression(PsiMethodCallExpression expression) { if ( MAPPERS_FACTORY_CALL_MATCHER.test( expression ) ) { PsiExpression argument = PsiUtil.skipParenthesizedExprDown( expression.getArgumentList() .getExpressions()[0] ); - if ( !( argument instanceof PsiClassObjectAccessExpression ) ) { + if ( !( argument instanceof PsiClassObjectAccessExpression classObjectAccessExpression ) ) { return; } - PsiClassObjectAccessExpression classObjectAccessExpression = (PsiClassObjectAccessExpression) argument; PsiJavaCodeReferenceElement referenceElement = classObjectAccessExpression.getOperand() .getInnermostComponentReferenceElement(); @@ -79,11 +78,10 @@ public void visitMethodCallExpression(PsiMethodCallExpression expression) { PsiElement mapperElement = referenceElement.resolve(); - if ( !( mapperElement instanceof PsiClass ) ) { + if ( !( mapperElement instanceof PsiClass mapperClass ) ) { return; } - PsiClass mapperClass = (PsiClass) mapperElement; PsiAnnotation mapperAnnotation = mapperClass.getAnnotation( MapstructUtil.MAPPER_ANNOTATION_FQN ); if ( mapperAnnotation == null ) { List fixes = new ArrayList<>(2); @@ -165,9 +163,9 @@ public String getFamilyName() { private static LocalQuickFix createRemoveMappersFix(@NotNull PsiMethodCallExpression methodCallExpression) { PsiElement parent = methodCallExpression.getParent(); - if ( parent instanceof PsiVariable ) { + if ( parent instanceof PsiVariable parentPsiVariable ) { - return new RemoveMappersFix( (PsiVariable) parent ); + return new RemoveMappersFix( parentPsiVariable ); } return null; diff --git a/src/main/java/org/mapstruct/intellij/util/MapstructAnnotationUtils.java b/src/main/java/org/mapstruct/intellij/util/MapstructAnnotationUtils.java index 56469743..fdbddb9c 100644 --- a/src/main/java/org/mapstruct/intellij/util/MapstructAnnotationUtils.java +++ b/src/main/java/org/mapstruct/intellij/util/MapstructAnnotationUtils.java @@ -147,8 +147,8 @@ public static void addMappingAnnotation(@NotNull Project project, private static void moveCaretToEmptySourceAttribute(@NotNull Project project, PsiElement element) { FileEditor selectedEditor = FileEditorManager.getInstance( project ).getSelectedEditor(); - if ( selectedEditor instanceof TextEditor ) { - Editor editor = ( (TextEditor) selectedEditor ).getEditor(); + if ( selectedEditor instanceof TextEditor textEditor ) { + Editor editor = textEditor.getEditor(); TextRange textRange = element.getTextRange(); String textOfElement = String.valueOf( editor.getDocument() @@ -301,14 +301,13 @@ private static Stream findAllDefinedMappingAnnotations(@NotNull P if ( mappings != null ) { //TODO maybe there is a better way to do this, but currently I don't have that much knowledge PsiAnnotationMemberValue mappingsValue = mappings.findDeclaredAttributeValue( null ); - if ( mappingsValue instanceof PsiArrayInitializerMemberValue ) { - mappingsAnnotations = Stream.of( ( (PsiArrayInitializerMemberValue) mappingsValue ) - .getInitializers() ) + if ( mappingsValue instanceof PsiArrayInitializerMemberValue mappingsArrayInitializerMemberValue ) { + mappingsAnnotations = Stream.of( mappingsArrayInitializerMemberValue.getInitializers() ) .filter( MapstructAnnotationUtils::isMappingPsiAnnotation ) .map( PsiAnnotation.class::cast ); } - else if ( mappingsValue instanceof PsiAnnotation ) { - mappingsAnnotations = Stream.of( (PsiAnnotation) mappingsValue ); + else if ( mappingsValue instanceof PsiAnnotation mappingsAnnotation ) { + mappingsAnnotations = Stream.of( mappingsAnnotation ); } } @@ -370,14 +369,13 @@ public static Stream findAllDefinedValueMappingAnnotations(@NotNu PsiAnnotation valueMappings = findAnnotation( method, true, MapstructUtil.VALUE_MAPPINGS_ANNOTATION_FQN ); if ( valueMappings != null ) { PsiAnnotationMemberValue mappingsValue = valueMappings.findDeclaredAttributeValue( null ); - if ( mappingsValue instanceof PsiArrayInitializerMemberValue ) { - valueMappingsAnnotations = Stream.of( ( (PsiArrayInitializerMemberValue) mappingsValue ) - .getInitializers() ) + if ( mappingsValue instanceof PsiArrayInitializerMemberValue mappingsArrayInitializerMemberValue ) { + valueMappingsAnnotations = Stream.of( mappingsArrayInitializerMemberValue.getInitializers() ) .filter( MapstructAnnotationUtils::isValueMappingPsiAnnotation ) .map( PsiAnnotation.class::cast ); } - else if ( mappingsValue instanceof PsiAnnotation ) { - valueMappingsAnnotations = Stream.of( (PsiAnnotation) mappingsValue ); + else if ( mappingsValue instanceof PsiAnnotation mappingsAnnotation ) { + valueMappingsAnnotations = Stream.of( mappingsAnnotation ); } } @@ -444,33 +442,33 @@ private static boolean isMappingAnnotation(PsiAnnotation psiAnnotation) { @Nullable public static PsiModifierListOwner findMapperConfigReference(@NotNull PsiAnnotation mapperAnnotation) { PsiAnnotationMemberValue configValue = mapperAnnotation.findDeclaredAttributeValue( "config" ); - if ( !( configValue instanceof PsiClassObjectAccessExpression ) ) { + if ( !( configValue instanceof PsiClassObjectAccessExpression configClassObjectAccessExpression ) ) { return null; } - PsiJavaCodeReferenceElement referenceElement = ( (PsiClassObjectAccessExpression) configValue ).getOperand() + PsiJavaCodeReferenceElement referenceElement = configClassObjectAccessExpression.getOperand() .getInnermostComponentReferenceElement(); if ( referenceElement == null ) { return null; } PsiElement resolvedElement = referenceElement.resolve(); - if ( !( resolvedElement instanceof PsiModifierListOwner ) ) { + if ( !( resolvedElement instanceof PsiModifierListOwner psiModifierListOwner ) ) { return null; } - return (PsiModifierListOwner) resolvedElement; + return psiModifierListOwner; } public static Optional findMapperConfigClass(@NotNull PsiAnnotation mapperAnnotation) { PsiModifierListOwner mapperConfigReference = findMapperConfigReference( mapperAnnotation ); - if ( !( mapperConfigReference instanceof PsiClass ) ) { + if ( !( mapperConfigReference instanceof PsiClass mapperPsiClass ) ) { return Optional.empty(); } - return Optional.of( (PsiClass) mapperConfigReference ); + return Optional.of( mapperPsiClass ); } /** @@ -494,14 +492,13 @@ private static Stream findReferencedMappers(@NotNull PsiAnnotation map PsiAnnotationMemberValue usesValue = mapperAnnotation.findDeclaredAttributeValue( "uses" ); Stream usesExpressions = Stream.empty(); - if ( usesValue instanceof PsiArrayInitializerMemberValue ) { - usesExpressions = Stream.of( ( (PsiArrayInitializerMemberValue) usesValue ) - .getInitializers() ) + if ( usesValue instanceof PsiArrayInitializerMemberValue psiArrayInitializerMemberValue ) { + usesExpressions = Stream.of( psiArrayInitializerMemberValue.getInitializers() ) .filter( PsiClassObjectAccessExpression.class::isInstance ) .map( PsiClassObjectAccessExpression.class::cast ); } - else if ( usesValue instanceof PsiClassObjectAccessExpression ) { - usesExpressions = Stream.of( (PsiClassObjectAccessExpression) usesValue ); + else if ( usesValue instanceof PsiClassObjectAccessExpression usedPsiClassObjectAccessExpression ) { + usesExpressions = Stream.of( usedPsiClassObjectAccessExpression ); } return usesExpressions @@ -608,18 +605,11 @@ public static PsiAnnotationMemberValue findConfigValueFromMapperConfig(@NotNull @NotNull private static ReportingPolicy getUnmappedTargetPolicyPolicyFromAnnotation( @NotNull PsiAnnotationMemberValue configValue) { - switch ( configValue.getText() ) { - case "IGNORE": - case "ReportingPolicy.IGNORE": - return ReportingPolicy.IGNORE; - case "ERROR": - case "ReportingPolicy.ERROR": - return ReportingPolicy.ERROR; - case "WARN": - case "ReportingPolicy.WARN": - default: - return ReportingPolicy.WARN; - } + return switch (configValue.getText()) { + case "IGNORE", "ReportingPolicy.IGNORE" -> ReportingPolicy.IGNORE; + case "ERROR", "ReportingPolicy.ERROR" -> ReportingPolicy.ERROR; + default -> ReportingPolicy.WARN; + }; } } diff --git a/src/main/java/org/mapstruct/intellij/util/SourceUtils.java b/src/main/java/org/mapstruct/intellij/util/SourceUtils.java index 4f918ce4..bd5468cf 100644 --- a/src/main/java/org/mapstruct/intellij/util/SourceUtils.java +++ b/src/main/java/org/mapstruct/intellij/util/SourceUtils.java @@ -114,11 +114,11 @@ public static PsiType getParameterType(@NotNull PsiParameter parameter) { public static Map> publicReadAccessors( @Nullable PsiElement psiElement) { - if ( psiElement instanceof PsiMethod ) { - return publicReadAccessors( ( (PsiMethod) psiElement ).getReturnType() ); + if ( psiElement instanceof PsiMethod psiMethod ) { + return publicReadAccessors( psiMethod.getReturnType() ); } - else if ( psiElement instanceof PsiParameter ) { - return publicReadAccessors( ( (PsiParameter) psiElement ).getType() ); + else if ( psiElement instanceof PsiParameter psiParameter ) { + return publicReadAccessors( psiParameter.getType() ); } return Collections.emptyMap(); diff --git a/src/main/java/org/mapstruct/intellij/util/TargetUtils.java b/src/main/java/org/mapstruct/intellij/util/TargetUtils.java index 4c42d55f..0432fd1b 100644 --- a/src/main/java/org/mapstruct/intellij/util/TargetUtils.java +++ b/src/main/java/org/mapstruct/intellij/util/TargetUtils.java @@ -179,8 +179,8 @@ private static Optional findDisableBuilder(@Nullable PsiModifierListOwn private static Optional findDisabledBuilder(@Nullable PsiAnnotation requestedAnnotation) { if ( requestedAnnotation != null ) { PsiAnnotationMemberValue builderValue = requestedAnnotation.findDeclaredAttributeValue( "builder" ); - if ( builderValue instanceof PsiAnnotation ) { - Boolean disableBuilder = getBooleanAttributeValue( (PsiAnnotation) builderValue, "disableBuilder" ); + if ( builderValue instanceof PsiAnnotation builderAnnotation ) { + Boolean disableBuilder = getBooleanAttributeValue( builderAnnotation, "disableBuilder" ); return Optional.ofNullable( disableBuilder ); } } diff --git a/src/main/java/org/mapstruct/intellij/util/patterns/KtValueArgumentNamePattern.java b/src/main/java/org/mapstruct/intellij/util/patterns/KtValueArgumentNamePattern.java index d5486a4b..85ef4ce2 100644 --- a/src/main/java/org/mapstruct/intellij/util/patterns/KtValueArgumentNamePattern.java +++ b/src/main/java/org/mapstruct/intellij/util/patterns/KtValueArgumentNamePattern.java @@ -30,8 +30,8 @@ public KtValueArgumentNamePattern withName(@NotNull ElementPattern name) @Nullable @Override public String getPropertyValue(@NotNull Object o) { - if ( o instanceof KtValueArgumentName ) { - return ( (KtValueArgumentName) o ).getAsName().getIdentifier(); + if ( o instanceof KtValueArgumentName ktValueArgumentName ) { + return ktValueArgumentName.getAsName().getIdentifier(); } return null; } diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml index 177692f9..3a561998 100644 --- a/src/main/resources/META-INF/plugin.xml +++ b/src/main/resources/META-INF/plugin.xml @@ -24,7 +24,7 @@ MapStruct - + diff --git a/src/test/java/org/mapstruct/intellij/ValueMappingCompletionTestCase.java b/src/test/java/org/mapstruct/intellij/ValueMappingCompletionTestCase.java index b01d5696..7a4702ee 100644 --- a/src/test/java/org/mapstruct/intellij/ValueMappingCompletionTestCase.java +++ b/src/test/java/org/mapstruct/intellij/ValueMappingCompletionTestCase.java @@ -22,57 +22,63 @@ public class ValueMappingCompletionTestCase extends MapstructBaseCompletionTestCase { @Language("JAVA") - private static final String SOURCE_VALUE_MAPPING_DYNAMIC = "import org.mapstruct.Mapper;\n" + - "import org.mapstruct.ValueMapping;\n" + - "import org.mapstruct.example.ExternalRoofType;\n" + - "import org.mapstruct.example.RoofType;\n" + - "\n" + - "@Mapper\n" + - "public interface RoofTypeMapper {\n" + - "\n" + - " %s" + - " ExternalRoofType map(RoofType type);\n" + - "}"; + private static final String SOURCE_VALUE_MAPPING_DYNAMIC = """ + import org.mapstruct.Mapper; + import org.mapstruct.ValueMapping; + import org.mapstruct.example.ExternalRoofType; + import org.mapstruct.example.RoofType; + + @Mapper + public interface RoofTypeMapper { + + %s\ + ExternalRoofType map(RoofType type); + }"""; @Language("JAVA") - private static final String SOURCE_VALUE_MAPPINGS_DYNAMIC = "import org.mapstruct.Mapper;\n" + - "import org.mapstruct.ValueMapping;\n" + - "import org.mapstruct.ValueMappings;\n" + - "import org.mapstruct.example.ExternalRoofType;\n" + - "import org.mapstruct.example.RoofType;\n" + - "\n" + - "@Mapper\n" + - "public interface RoofTypeMapper {\n" + - "\n" + - " @ValueMappings({\n%s\n})\n" + - " ExternalRoofType map(RoofType type);\n" + - "}"; + private static final String SOURCE_VALUE_MAPPINGS_DYNAMIC = """ + import org.mapstruct.Mapper; + import org.mapstruct.ValueMapping; + import org.mapstruct.ValueMappings; + import org.mapstruct.example.ExternalRoofType; + import org.mapstruct.example.RoofType; + + @Mapper + public interface RoofTypeMapper { + + @ValueMappings({ + %s + }) + ExternalRoofType map(RoofType type); + }"""; @Language("JAVA") - private static final String SOURCE_VALUE_MAPPING = "import org.mapstruct.Mapper;\n" + - "import org.mapstruct.ValueMapping;\n" + - "import org.mapstruct.example.ExternalRoofType;\n" + - "import org.mapstruct.example.RoofType;\n" + - "\n" + - "@Mapper\n" + - "public interface RoofTypeMapper {\n" + - "\n" + - " @ValueMapping(source = \"%s\", target = \"STANDARD\")\n" + - " ExternalRoofType map(RoofType type);\n" + - "}"; + private static final String SOURCE_VALUE_MAPPING = """ + import org.mapstruct.Mapper; + import org.mapstruct.ValueMapping; + import org.mapstruct.example.ExternalRoofType; + import org.mapstruct.example.RoofType; + + @Mapper + public interface RoofTypeMapper { + + @ValueMapping(source = "%s", target = "STANDARD") + ExternalRoofType map(RoofType type); + }"""; @Language("JAVA") - private static final String TARGET_VALUE_MAPPING = "import org.mapstruct.Mapper;\n" + - "import org.mapstruct.ValueMapping;\n" + - "import org.mapstruct.example.ExternalRoofType;\n" + - "import org.mapstruct.example.RoofType;\n" + - "\n" + - "@Mapper\n" + - "public interface RoofTypeMapper {\n" + - "\n" + - " @ValueMapping(source = \"NORMAL\", target = \"%s\")\n" + - " ExternalRoofType map(RoofType type);\n" + - "}"; + private static final String TARGET_VALUE_MAPPING = """ + import org.mapstruct.Mapper; + import org.mapstruct.ValueMapping; + import org.mapstruct.example.ExternalRoofType; + import org.mapstruct.example.RoofType; + + @Mapper + public interface RoofTypeMapper { + + @ValueMapping(source = "NORMAL", target = "%s") + ExternalRoofType map(RoofType type); + }"""; @Override protected String getTestDataPath() { @@ -112,8 +118,10 @@ public void testSourceValueMappingVariants() { public void testSourceValueMappingWithExisting() { String source = String.format( SOURCE_VALUE_MAPPING_DYNAMIC, - "@ValueMapping(source = \"GAMBREL\", target = \"NORMAL\")\n" + - "@ValueMapping(source = \"%s\", target = \"STANDARD\")\n" + """ + @ValueMapping(source = "GAMBREL", target = "NORMAL") + @ValueMapping(source = "%s", target = "STANDARD") + """ ); myFixture.configureByText( JavaFileType.INSTANCE, source ); complete(); @@ -138,8 +146,10 @@ public void testSourceValueMappingWithExisting() { public void testSourceValueMappingsWithExisting() { String source = String.format( SOURCE_VALUE_MAPPINGS_DYNAMIC, - "@ValueMapping(source = \"GAMBREL\", target = \"NORMAL\"),\n" + - "@ValueMapping(source = \"%s\", target = \"STANDARD\")\n" + """ + @ValueMapping(source = "GAMBREL", target = "NORMAL"), + @ValueMapping(source = "%s", target = "STANDARD") + """ ); myFixture.configureByText( JavaFileType.INSTANCE, source ); complete(); @@ -164,11 +174,13 @@ public void testSourceValueMappingsWithExisting() { public void testSourceValueMappingAllValuesAlreadyMapped() { String source = String.format( SOURCE_VALUE_MAPPING_DYNAMIC, - "@ValueMapping(source = \"OPEN\", target = \"NORMAL\")\n" + - "@ValueMapping(source = \"BOX\", target = \"NORMAL\")\n" + - "@ValueMapping(source = \"GAMBREL\", target = \"NORMAL\")\n" + - "@ValueMapping(source = \"NORMAL\", target = \"NORMAL\")\n" + - "@ValueMapping(source = \"%s\", target = \"STANDARD\")\n" + """ + @ValueMapping(source = "OPEN", target = "NORMAL") + @ValueMapping(source = "BOX", target = "NORMAL") + @ValueMapping(source = "GAMBREL", target = "NORMAL") + @ValueMapping(source = "NORMAL", target = "NORMAL") + @ValueMapping(source = "%s", target = "STANDARD") + """ ); myFixture.configureByText( JavaFileType.INSTANCE, source ); complete(); @@ -185,11 +197,13 @@ public void testSourceValueMappingAllValuesAlreadyMapped() { public void testSourceValueMappingsAllValuesAlreadyMapped() { String source = String.format( SOURCE_VALUE_MAPPINGS_DYNAMIC, - "@ValueMapping(source = \"OPEN\", target = \"NORMAL\"),\n" + - "@ValueMapping(source = \"BOX\", target = \"NORMAL\"),\n" + - "@ValueMapping(source = \"GAMBREL\", target = \"NORMAL\"),\n" + - "@ValueMapping(source = \"NORMAL\", target = \"NORMAL\"),\n" + - "@ValueMapping(source = \"%s\", target = \"STANDARD\")\n" + """ + @ValueMapping(source = "OPEN", target = "NORMAL"), + @ValueMapping(source = "BOX", target = "NORMAL"), + @ValueMapping(source = "GAMBREL", target = "NORMAL"), + @ValueMapping(source = "NORMAL", target = "NORMAL"), + @ValueMapping(source = "%s", target = "STANDARD") + """ ); myFixture.configureByText( JavaFileType.INSTANCE, source ); complete(); diff --git a/src/test/java/org/mapstruct/intellij/expression/JavaExpressionInjectionTest.java b/src/test/java/org/mapstruct/intellij/expression/JavaExpressionInjectionTest.java index ecb83417..eb948dba 100644 --- a/src/test/java/org/mapstruct/intellij/expression/JavaExpressionInjectionTest.java +++ b/src/test/java/org/mapstruct/intellij/expression/JavaExpressionInjectionTest.java @@ -354,20 +354,21 @@ protected void withMapperWithImports(String attribute) { String mapper = formatMapper( CAR_MAPPER, mapping, "imports = java.util.Collections.class" ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import java.util.Collections;\n" + - "import org.example.dto.Car;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car\n" + - " ) {\n" + - " return Collections;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import java.util.Collections; + import org.example.dto.Car; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Car car + ) { + return Collections; + } + }""" ); } @@ -383,20 +384,21 @@ protected void withMapperWithCustomImports(String attribute) { String mapper = formatMapper( CAR_MAPPER, mapping, "imports = org.example.dto.Utils.class" ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "import org.example.dto.Utils;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car\n" + - " ) {\n" + - " return Utils;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + import org.example.dto.Utils; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Car car + ) { + return Utils; + } + }""" ); } public void testExpressionWithMapperWithoutImports() { @@ -411,19 +413,20 @@ protected void withMapperWithoutImports(String attribute) { String mapper = formatMapper( CAR_MAPPER, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car\n" + - " ) {\n" + - " return Collections;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Car car + ) { + return Collections; + } + }""" ); } @@ -439,20 +442,21 @@ protected void withMultiSourceParameters(String attribute) { String mapper = formatMapper( CAR_MAPPER_MULTI_SOURCE, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car,\n" + - " String make\n" + - " ) {\n" + - " return car.;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Car car, + String make + ) { + return car.; + } + }""" ); } public void testExpressionWithGenericSourceParameters() { @@ -468,20 +472,21 @@ protected void withGenericSourceParameters(String attribute) { String mapper = formatMapper( CAR_MAPPER_FROM_WRAPPER, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "import org.example.dto.Wrapper;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Wrapper carWrapper\n" + - " ) {\n" + - " return carWrapper.getValue().;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + import org.example.dto.Wrapper; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Wrapper carWrapper + ) { + return carWrapper.getValue().; + } + }""" ); } public void testExpressionWithSourceParameterWithAnnotations() { @@ -497,21 +502,22 @@ protected void withExpressionWithSourceParameterWithAnnotations(String attribute String mapper = formatMapper( CAR_MAPPER_FROM_WRAPPER_WITH_ANNOTATION, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "import org.example.dto.Wrapper;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " @Context\n" + - " Wrapper carWrapper\n" + - " ) {\n" + - " return carWrapper.getValue().;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + import org.example.dto.Wrapper; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + @Context + Wrapper carWrapper + ) { + return carWrapper.getValue().; + } + }""" ); } public void testExpressionWithSourceParameterWithMultipleGenerics() { @@ -527,21 +533,22 @@ protected void withExpressionWithSourceParameterWithMultipleGenerics(String attr String mapper = formatMapper( CAR_MAPPER_FROM_WRAPPER_WITH_MULTI_GENERICS, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import java.util.function.BiFunction;\n" + - "import org.example.dto.Car;\n" + - "import org.example.dto.Wrapper;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Wrapper> carWrapper\n" + - " ) {\n" + - " return carWrapper.getValue().apply(null, null).;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import java.util.function.BiFunction; + import org.example.dto.Car; + import org.example.dto.Wrapper; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Wrapper> carWrapper + ) { + return carWrapper.getValue().apply(null, null).; + } + }""" ); } public void testExpressionWithGenericMethod() { @@ -556,19 +563,20 @@ protected void withExpressionWithGenericMethod(String attribute) { String mapper = formatMapper( CAR_MAPPER_FROM_NUMBER_WRAPPER, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.NumberWrapper;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " int __test__(\n" + - " NumberWrapper numberWrapper\n" + - " ) {\n" + - " return numberWrapper.;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.NumberWrapper; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + int __test__( + NumberWrapper numberWrapper + ) { + return numberWrapper.; + } + }""" ); } public void testExpressionWithGenericMapper() { @@ -583,20 +591,21 @@ protected void withGenericMapper(String attribute) { String mapper = formatMapper( GENERIC_MAPPER, mapping ); configureMapperByText( mapper ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " implements CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car,\n" + - " String make\n" + - " ) {\n" + - " return car.;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + implements CarMapper { + + String __test__( + Car car, + String make + ) { + return car.; + } + }""" ); } public void testExpressionWithClassMapper() { @@ -619,19 +628,20 @@ protected void withClassMapper(String attribute) { " CarDto carToCarDto(Car car);\n" + "}" ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " extends CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car\n" + - " ) {\n" + - " return car.;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + extends CarMapper { + + String __test__( + Car car + ) { + return car.; + } + }""" ); } public void testExpressionWithTargetUsingStaticString() { @@ -655,19 +665,20 @@ protected void withTargetUsingStaticString(String attribute) { " CarDto carToCarDto(Car car);\n" + "}" ); - assertJavaFragment( "import CarMapper;\n" + - "import org.example.dto.Car;\n" + - "\n" + - "@SuppressWarnings(\"unused\")\n" + - "abstract class CarMapperImpl\n" + - " extends CarMapper {\n" + - "\n" + - " String __test__(\n" + - " Car car\n" + - " ) {\n" + - " return car.;\n" + - " }\n" + - "}" ); + assertJavaFragment( """ + import CarMapper; + import org.example.dto.Car; + + @SuppressWarnings("unused") + abstract class CarMapperImpl + extends CarMapper { + + String __test__( + Car car + ) { + return car.; + } + }""" ); } public void testExpressionWithMapperToDtoWithoutAccessors() { diff --git a/src/test/java/org/mapstruct/intellij/inspection/UnmappedTargetPropertiesInspectionCaretAfterQuickfixTest.java b/src/test/java/org/mapstruct/intellij/inspection/UnmappedTargetPropertiesInspectionCaretAfterQuickfixTest.java index 7152a483..c3f2624a 100644 --- a/src/test/java/org/mapstruct/intellij/inspection/UnmappedTargetPropertiesInspectionCaretAfterQuickfixTest.java +++ b/src/test/java/org/mapstruct/intellij/inspection/UnmappedTargetPropertiesInspectionCaretAfterQuickfixTest.java @@ -6,7 +6,6 @@ package org.mapstruct.intellij.inspection; import java.util.List; -import java.util.stream.Collectors; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.editor.Caret; @@ -40,7 +39,7 @@ public void testAddUnmappedTargetProperties() { List addMissingTargetQuickfixes = myFixture.getAllQuickFixes() .stream() .filter( i -> i.getText().startsWith( "Add unmapped target property " ) ) - .collect( Collectors.toList() ); + .toList(); addMissingTargetQuickfixes.forEach( this::launchAndAssertCaretPositionInSource ); } @@ -51,7 +50,7 @@ public void testIgnoreUnmappedTargetProperties() { List addMissingTargetQuickfixes = myFixture.getAllQuickFixes() .stream() .filter( i -> i.getText().startsWith( "Ignore unmapped target property" ) ) - .collect( Collectors.toList() ); + .toList(); addMissingTargetQuickfixes.forEach( this::launchAndAssertUnchangedCaretPosition ); } @@ -62,7 +61,7 @@ public void testIgnoreAllUnmappedTargetProperties() { List addMissingTargetQuickfixes = myFixture.getAllQuickFixes() .stream() .filter( i -> i.getText().startsWith( "Ignore all unmapped target properties" ) ) - .collect( Collectors.toList() ); + .toList(); addMissingTargetQuickfixes.forEach( this::launchAndAssertUnchangedCaretPosition ); }