diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java index 9951649776db..974a33b432c5 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java @@ -70,7 +70,6 @@ import java.util.*; import java.util.function.Function; import java.util.regex.Matcher; import java.util.regex.Pattern; -import java.util.stream.Stream; public final class HighlightUtil { public static final Set RESTRICTED_RECORD_COMPONENT_NAMES = Set.of( @@ -87,60 +86,60 @@ public final class HighlightUtil { private static final Map> ourRequiresIncompatibleModifiers = new THashMap<>(2); private static final Set ourConstructorNotAllowedModifiers = - ContainerUtil.newTroveSet(PsiModifier.ABSTRACT, PsiModifier.STATIC, PsiModifier.NATIVE, PsiModifier.FINAL, PsiModifier.STRICTFP, PsiModifier.SYNCHRONIZED); + Set.of(PsiModifier.ABSTRACT, PsiModifier.STATIC, PsiModifier.NATIVE, PsiModifier.FINAL, PsiModifier.STRICTFP, PsiModifier.SYNCHRONIZED); private static final String SERIAL_PERSISTENT_FIELDS_FIELD_NAME = "serialPersistentFields"; static { - ourClassIncompatibleModifiers.put(PsiModifier.ABSTRACT, ContainerUtil.newTroveSet(PsiModifier.FINAL)); - ourClassIncompatibleModifiers.put(PsiModifier.FINAL, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT, PsiModifier.SEALED, PsiModifier.NON_SEALED)); - ourClassIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, ContainerUtil.newTroveSet(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourClassIncompatibleModifiers.put(PsiModifier.PRIVATE, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourClassIncompatibleModifiers.put(PsiModifier.PUBLIC, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); - ourClassIncompatibleModifiers.put(PsiModifier.PROTECTED, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); - ourClassIncompatibleModifiers.put(PsiModifier.STRICTFP, Collections.emptySet()); - ourClassIncompatibleModifiers.put(PsiModifier.STATIC, Collections.emptySet()); - ourClassIncompatibleModifiers.put(PsiModifier.SEALED, ContainerUtil.newTroveSet(PsiModifier.FINAL, PsiModifier.NON_SEALED)); - ourClassIncompatibleModifiers.put(PsiModifier.NON_SEALED, ContainerUtil.newTroveSet(PsiModifier.FINAL, PsiModifier.SEALED)); + ourClassIncompatibleModifiers.put(PsiModifier.ABSTRACT, Set.of(PsiModifier.FINAL)); + ourClassIncompatibleModifiers.put(PsiModifier.FINAL, Set.of(PsiModifier.ABSTRACT, PsiModifier.SEALED, PsiModifier.NON_SEALED)); + ourClassIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, Set.of(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourClassIncompatibleModifiers.put(PsiModifier.PRIVATE, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourClassIncompatibleModifiers.put(PsiModifier.PUBLIC, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); + ourClassIncompatibleModifiers.put(PsiModifier.PROTECTED, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); + ourClassIncompatibleModifiers.put(PsiModifier.STRICTFP, Set.of()); + ourClassIncompatibleModifiers.put(PsiModifier.STATIC, Set.of()); + ourClassIncompatibleModifiers.put(PsiModifier.SEALED, Set.of(PsiModifier.FINAL, PsiModifier.NON_SEALED)); + ourClassIncompatibleModifiers.put(PsiModifier.NON_SEALED, Set.of(PsiModifier.FINAL, PsiModifier.SEALED)); - ourInterfaceIncompatibleModifiers.put(PsiModifier.ABSTRACT, Collections.emptySet()); - ourInterfaceIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, ContainerUtil.newTroveSet(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourInterfaceIncompatibleModifiers.put(PsiModifier.PRIVATE, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourInterfaceIncompatibleModifiers.put(PsiModifier.PUBLIC, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); - ourInterfaceIncompatibleModifiers.put(PsiModifier.PROTECTED, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); - ourInterfaceIncompatibleModifiers.put(PsiModifier.STRICTFP, Collections.emptySet()); - ourInterfaceIncompatibleModifiers.put(PsiModifier.STATIC, Collections.emptySet()); - ourInterfaceIncompatibleModifiers.put(PsiModifier.SEALED, ContainerUtil.newTroveSet(PsiModifier.NON_SEALED)); - ourInterfaceIncompatibleModifiers.put(PsiModifier.NON_SEALED, ContainerUtil.newTroveSet(PsiModifier.SEALED)); + ourInterfaceIncompatibleModifiers.put(PsiModifier.ABSTRACT, Set.of()); + ourInterfaceIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, Set.of(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourInterfaceIncompatibleModifiers.put(PsiModifier.PRIVATE, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourInterfaceIncompatibleModifiers.put(PsiModifier.PUBLIC, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); + ourInterfaceIncompatibleModifiers.put(PsiModifier.PROTECTED, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); + ourInterfaceIncompatibleModifiers.put(PsiModifier.STRICTFP, Set.of()); + ourInterfaceIncompatibleModifiers.put(PsiModifier.STATIC, Set.of()); + ourInterfaceIncompatibleModifiers.put(PsiModifier.SEALED, Set.of(PsiModifier.NON_SEALED)); + ourInterfaceIncompatibleModifiers.put(PsiModifier.NON_SEALED, Set.of(PsiModifier.SEALED)); - ourMethodIncompatibleModifiers.put(PsiModifier.ABSTRACT, ContainerUtil.newTroveSet( + ourMethodIncompatibleModifiers.put(PsiModifier.ABSTRACT, Set.of( PsiModifier.NATIVE, PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PRIVATE, PsiModifier.STRICTFP, PsiModifier.SYNCHRONIZED, PsiModifier.DEFAULT)); - ourMethodIncompatibleModifiers.put(PsiModifier.NATIVE, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT, PsiModifier.STRICTFP)); - ourMethodIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, ContainerUtil.newTroveSet(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourMethodIncompatibleModifiers.put(PsiModifier.PRIVATE, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourMethodIncompatibleModifiers.put(PsiModifier.PUBLIC, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); - ourMethodIncompatibleModifiers.put(PsiModifier.PROTECTED, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); - ourMethodIncompatibleModifiers.put(PsiModifier.STATIC, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT, PsiModifier.DEFAULT, PsiModifier.FINAL)); - ourMethodIncompatibleModifiers.put(PsiModifier.DEFAULT, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT, PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PRIVATE)); - ourMethodIncompatibleModifiers.put(PsiModifier.SYNCHRONIZED, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT)); - ourMethodIncompatibleModifiers.put(PsiModifier.STRICTFP, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT)); - ourMethodIncompatibleModifiers.put(PsiModifier.FINAL, ContainerUtil.newTroveSet(PsiModifier.ABSTRACT)); + ourMethodIncompatibleModifiers.put(PsiModifier.NATIVE, Set.of(PsiModifier.ABSTRACT, PsiModifier.STRICTFP)); + ourMethodIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, Set.of(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourMethodIncompatibleModifiers.put(PsiModifier.PRIVATE, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourMethodIncompatibleModifiers.put(PsiModifier.PUBLIC, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); + ourMethodIncompatibleModifiers.put(PsiModifier.PROTECTED, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); + ourMethodIncompatibleModifiers.put(PsiModifier.STATIC, Set.of(PsiModifier.ABSTRACT, PsiModifier.DEFAULT, PsiModifier.FINAL)); + ourMethodIncompatibleModifiers.put(PsiModifier.DEFAULT, Set.of(PsiModifier.ABSTRACT, PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PRIVATE)); + ourMethodIncompatibleModifiers.put(PsiModifier.SYNCHRONIZED, Set.of(PsiModifier.ABSTRACT)); + ourMethodIncompatibleModifiers.put(PsiModifier.STRICTFP, Set.of(PsiModifier.ABSTRACT)); + ourMethodIncompatibleModifiers.put(PsiModifier.FINAL, Set.of(PsiModifier.ABSTRACT)); - ourFieldIncompatibleModifiers.put(PsiModifier.FINAL, ContainerUtil.newTroveSet(PsiModifier.VOLATILE)); - ourFieldIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, ContainerUtil.newTroveSet(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourFieldIncompatibleModifiers.put(PsiModifier.PRIVATE, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); - ourFieldIncompatibleModifiers.put(PsiModifier.PUBLIC, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); - ourFieldIncompatibleModifiers.put(PsiModifier.PROTECTED, ContainerUtil.newTroveSet(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); - ourFieldIncompatibleModifiers.put(PsiModifier.STATIC, Collections.emptySet()); - ourFieldIncompatibleModifiers.put(PsiModifier.TRANSIENT, Collections.emptySet()); - ourFieldIncompatibleModifiers.put(PsiModifier.VOLATILE, ContainerUtil.newTroveSet(PsiModifier.FINAL)); + ourFieldIncompatibleModifiers.put(PsiModifier.FINAL, Set.of(PsiModifier.VOLATILE)); + ourFieldIncompatibleModifiers.put(PsiModifier.PACKAGE_LOCAL, Set.of(PsiModifier.PRIVATE, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourFieldIncompatibleModifiers.put(PsiModifier.PRIVATE, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PROTECTED)); + ourFieldIncompatibleModifiers.put(PsiModifier.PUBLIC, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PRIVATE, PsiModifier.PROTECTED)); + ourFieldIncompatibleModifiers.put(PsiModifier.PROTECTED, Set.of(PsiModifier.PACKAGE_LOCAL, PsiModifier.PUBLIC, PsiModifier.PRIVATE)); + ourFieldIncompatibleModifiers.put(PsiModifier.STATIC, Set.of()); + ourFieldIncompatibleModifiers.put(PsiModifier.TRANSIENT, Set.of()); + ourFieldIncompatibleModifiers.put(PsiModifier.VOLATILE, Set.of(PsiModifier.FINAL)); - ourClassInitializerIncompatibleModifiers.put(PsiModifier.STATIC, Collections.emptySet()); + ourClassInitializerIncompatibleModifiers.put(PsiModifier.STATIC, Set.of()); - ourModuleIncompatibleModifiers.put(PsiModifier.OPEN, Collections.emptySet()); + ourModuleIncompatibleModifiers.put(PsiModifier.OPEN, Set.of()); - ourRequiresIncompatibleModifiers.put(PsiModifier.STATIC, Collections.emptySet()); - ourRequiresIncompatibleModifiers.put(PsiModifier.TRANSITIVE, Collections.emptySet()); + ourRequiresIncompatibleModifiers.put(PsiModifier.STATIC, Set.of()); + ourRequiresIncompatibleModifiers.put(PsiModifier.TRANSITIVE, Set.of()); } private HighlightUtil() { } @@ -484,7 +483,7 @@ public final class HighlightUtil { private static boolean isArray(@NotNull PsiVariable variable) { // Java-style 'var' arrays are prohibited by the parser; for C-style ones, looking for a bracket is enough - return Stream.of(variable.getChildren()).anyMatch(e -> PsiUtil.isJavaToken(e, JavaTokenType.LBRACKET)); + return ContainerUtil.or(variable.getChildren(), e -> PsiUtil.isJavaToken(e, JavaTokenType.LBRACKET)); } static HighlightInfo checkAssignability(@Nullable PsiType lType, @@ -1599,6 +1598,30 @@ public final class HighlightUtil { return null; } + static HighlightInfo checkRecordComponentCStyleDeclaration(@NotNull PsiRecordComponent component) { + PsiIdentifier identifier = component.getNameIdentifier(); + if (identifier == null) return null; + PsiElement start = null; + PsiElement end = null; + for (PsiElement element = identifier.getNextSibling(); element != null; element = element.getNextSibling()) { + if (start == null && PsiUtil.isJavaToken(element, JavaTokenType.LBRACKET)) { + start = element; + } + if (PsiUtil.isJavaToken(element, JavaTokenType.RBRACKET)) { + end = element; + } + } + if (start != null && end != null) { + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(component, start.getTextRange().getStartOffset(), end.getTextRange().getEndOffset()) + .descriptionAndTooltip(JavaErrorBundle.message("record.component.cstyle.declaration")).create(); + QuickFixAction.registerQuickFixAction(info, new NormalizeRecordComponentFix(component)); + return info; + } + return null; + } + + /** * This method validates that the language level of the project where the context accesses * the owner that is annotated with {@link HighlightingFeature#JDK_INTERNAL_PREVIEW_FEATURE} is sufficient diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java index bdf6ae958733..a0b50fd20fff 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java @@ -1123,6 +1123,9 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh public void visitRecordComponent(PsiRecordComponent recordComponent) { super.visitRecordComponent(recordComponent); if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkRecordComponentVarArg(recordComponent)); + if (!myHolder.hasErrorResults() && myLanguageLevel != LanguageLevel.JDK_14_PREVIEW) { + myHolder.add(HighlightUtil.checkRecordComponentCStyleDeclaration(recordComponent)); + } if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkRecordComponentName(recordComponent)); if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkRecordComponentInitialized(recordComponent)); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/NormalizeRecordComponentFix.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/NormalizeRecordComponentFix.java new file mode 100644 index 000000000000..a9268837a69e --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/NormalizeRecordComponentFix.java @@ -0,0 +1,40 @@ +// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.codeInsight.daemon.impl.quickfix; + +import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; +import com.intellij.codeInspection.util.IntentionFamilyName; +import com.intellij.codeInspection.util.IntentionName; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.psi.PsiRecordComponent; +import com.intellij.psi.impl.source.tree.JavaSharedImplUtil; +import com.siyeh.InspectionGadgetsBundle; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +public final class NormalizeRecordComponentFix extends LocalQuickFixAndIntentionActionOnPsiElement { + public NormalizeRecordComponentFix(PsiRecordComponent component) { + super(component); + } + + @Override + public void invoke(@NotNull Project project, + @NotNull PsiFile file, + @Nullable Editor editor, + @NotNull PsiElement startElement, + @NotNull PsiElement endElement) { + JavaSharedImplUtil.normalizeBrackets((PsiRecordComponent)startElement); + } + + @Override + public @IntentionName @NotNull String getText() { + return getFamilyName(); + } + + @Override + public @IntentionFamilyName @NotNull String getFamilyName() { + return InspectionGadgetsBundle.message("c.style.array.declaration.replace.quickfix"); + } +} diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSharedImplUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSharedImplUtil.java index 5638d98d0ed2..901dc4dd8a69 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSharedImplUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaSharedImplUtil.java @@ -162,17 +162,18 @@ public final class JavaSharedImplUtil { } CompositeElement newType = (CompositeElement)type.clone(); - for (int i = 0; i < arrayCount; i++) { + if (!(typeElement.getType() instanceof PsiArrayType)) { CompositeElement newType1 = ASTFactory.composite(JavaElementType.TYPE); newType1.rawAddChildren(newType); - - annotationElementsToMove.get(i).forEach(newType1::rawAddChildren); - - newType1.rawAddChildren(ASTFactory.leaf(JavaTokenType.LBRACKET, "[")); - newType1.rawAddChildren(ASTFactory.leaf(JavaTokenType.RBRACKET, "]")); newType = newType1; - newType.acceptTree(new GeneratedMarkerVisitor()); } + for (int i = 0; i < arrayCount; i++) { + annotationElementsToMove.get(i).forEach(newType::rawAddChildren); + + newType.rawAddChildren(ASTFactory.leaf(JavaTokenType.LBRACKET, "[")); + newType.rawAddChildren(ASTFactory.leaf(JavaTokenType.RBRACKET, "]")); + } + newType.acceptTree(new GeneratedMarkerVisitor()); newType.putUserData(CharTable.CHAR_TABLE_KEY, SharedImplUtil.findCharTableByTree(type)); CodeEditUtil.replaceChild(variableElement, type, newType); } diff --git a/java/java-psi-impl/src/messages/JavaErrorBundle.properties b/java/java-psi-impl/src/messages/JavaErrorBundle.properties index 480349698047..57049b5d6d31 100644 --- a/java/java-psi-impl/src/messages/JavaErrorBundle.properties +++ b/java/java-psi-impl/src/messages/JavaErrorBundle.properties @@ -422,6 +422,7 @@ record.no.header=Record has no header declared record.header.regular.class=Record header declared for non-record record.extends=No extends clause allowed for record record.component.vararg.not.last=Vararg record component must be the last in the list +record.component.cstyle.declaration=C-style record component declaration is not allowed record.component.restricted.name=Illegal record component name ''{0}'' record.instance.initializer=Instance initializer is not allowed in record record.instance.field=Instance field is not allowed in record diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasics.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasics.java index 35f3a03f3658..32c16e6fdbd1 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasics.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasics.java @@ -70,4 +70,5 @@ record ProhibitedMembers() { record StaticFieldCollides(int i) { static int i; } -record Incomplete(@int a) {} \ No newline at end of file +record Incomplete(@int a) {} +record CStyle(int a[]) {} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasicsJava15.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasicsJava15.java new file mode 100644 index 000000000000..71303e1f9945 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlightingRecords/RecordBasicsJava15.java @@ -0,0 +1,5 @@ +import java.lang.annotation.*; + +record CStyle(int a[]) {} +record CStyle2(int[] a[] [] ) {} +record JavaStyle(int[] [] a) {} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/after2D.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/after2D.java new file mode 100644 index 000000000000..ced393f43187 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/after2D.java @@ -0,0 +1,2 @@ +// "Replace with Java-style array declaration" "true" +record X (int[][] a){} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/afterMixed.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/afterMixed.java new file mode 100644 index 000000000000..6c0c399b7296 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/afterMixed.java @@ -0,0 +1,2 @@ +// "Replace with Java-style array declaration" "true" +record X (int[][][] a){} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/afterSimple.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/afterSimple.java new file mode 100644 index 000000000000..3d17182ded78 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/afterSimple.java @@ -0,0 +1,2 @@ +// "Replace with Java-style array declaration" "true" +record X (int[] a){} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/before2D.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/before2D.java new file mode 100644 index 000000000000..3956c04b4495 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/before2D.java @@ -0,0 +1,2 @@ +// "Replace with Java-style array declaration" "true" +record X (int a[][]){} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/beforeMixed.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/beforeMixed.java new file mode 100644 index 000000000000..ec3da63690ea --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/beforeMixed.java @@ -0,0 +1,2 @@ +// "Replace with Java-style array declaration" "true" +record X (int[] a[][]){} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/beforeSimple.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/beforeSimple.java new file mode 100644 index 000000000000..828e20c2ab98 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent/beforeSimple.java @@ -0,0 +1,2 @@ +// "Replace with Java-style array declaration" "true" +record X (int a[]){} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightRecordsHighlightingTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightRecordsHighlightingTest.java index 5f9f12bc0ebd..97c191b4ac02 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightRecordsHighlightingTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightRecordsHighlightingTest.java @@ -23,6 +23,9 @@ public class LightRecordsHighlightingTest extends LightJavaCodeInsightFixtureTes public void testRecordBasics() { doTest(); } + public void testRecordBasicsJava15() { + IdeaTestUtil.withLevel(getModule(), LanguageLevel.JDK_15_PREVIEW, this::doTest); + } public void testRecordAccessors() { doTest(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/NormalizeRecordComponentFixTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/NormalizeRecordComponentFixTest.java new file mode 100644 index 000000000000..0f4cff9c907b --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/NormalizeRecordComponentFixTest.java @@ -0,0 +1,34 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.java.codeInsight.daemon.quickFix; + +import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; +import com.intellij.testFramework.LightProjectDescriptor; +import org.jetbrains.annotations.NotNull; + +import static com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase.JAVA_15; + +public class NormalizeRecordComponentFixTest extends LightQuickFixParameterizedTestCase { + @Override + protected @NotNull LightProjectDescriptor getProjectDescriptor() { + return JAVA_15; + } + + @Override + protected String getBasePath() { + return "/codeInsight/daemonCodeAnalyzer/quickFix/normalizeRecordComponent"; + } +}