diff --git a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java index 4088df6af1d..c7e256d4c9b 100644 --- a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java +++ b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java @@ -116,6 +116,7 @@ private CorrectionMessages() { public static String LocalCorrectionsSubProcessor_add_permitted_types_description; public static String LocalCorrectionsSubProcessor_remove_default_case_description; public static String LocalCorrectionsSubProcessor_add_missing_cases_description; + public static String LocalCorrectionsSubProcessor_add_missing_cases_description_alphabetical; public static String LocalCorrectionsSubProcessor_addthrows_description; public static String ClasspathFixProcessorDescriptor_error_processing_processors; public static String LocalCorrectionsSubProcessor_addadditionalcatch_description; diff --git a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties index b5b682f967f..1124e69d484 100644 --- a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties +++ b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties @@ -91,6 +91,7 @@ LocalCorrectionsSubProcessor_add_default_case_label_description=Add 'default' ca LocalCorrectionsSubProcessor_add_permitted_types_description=Add permitted type cases LocalCorrectionsSubProcessor_remove_default_case_description=Remove 'default' case LocalCorrectionsSubProcessor_add_missing_cases_description=Add missing case statements +LocalCorrectionsSubProcessor_add_missing_cases_description_alphabetical=Add missing case statements (Alphabetically) LocalCorrectionsSubProcessor_addthrows_description=Add throws declaration ClasspathFixProcessorDescriptor_error_processing_processors=Exception while processing classpath fix processors LocalCorrectionsSubProcessor_addadditionalcatch_description=Add catch clause to surrounding try diff --git a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsBaseSubProcessor.java b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsBaseSubProcessor.java index 953ba234c4c..1996180e63b 100644 --- a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsBaseSubProcessor.java +++ b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsBaseSubProcessor.java @@ -17,6 +17,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.Hashtable; @@ -1171,11 +1172,17 @@ private String[] getMethod(String fieldName) { return resolveMap.get(fieldName); } - public void getMissingEnumConstantCaseProposalsBase(IInvocationContext context, IProblemLocation problem, Collection proposals) { + public void getMissingEnumConstantCaseProposalsBase(IInvocationContext context, IProblemLocation problem, Collection proposals, boolean preserveOrder) { for (T proposal : proposals) { if (proposal instanceof ChangeCorrectionProposalCore) { - if (CorrectionMessages.LocalCorrectionsSubProcessor_add_missing_cases_description.equals(((ChangeCorrectionProposalCore) proposal).getName())) { - return; + if (preserveOrder) { + if (CorrectionMessages.LocalCorrectionsSubProcessor_add_missing_cases_description.equals(((ChangeCorrectionProposalCore) proposal).getName())) { + return; + } + } else { + if (CorrectionMessages.LocalCorrectionsSubProcessor_add_missing_cases_description_alphabetical.equals(((ChangeCorrectionProposalCore) proposal).getName())) { + return; + } } } } @@ -1204,17 +1211,27 @@ public void getMissingEnumConstantCaseProposalsBase(IInvocationContext context, } ArrayList missingEnumCases= new ArrayList<>(); - boolean hasDefault= evaluateMissingSwitchCasesBase(binding, statements, missingEnumCases); + boolean hasDefault= evaluateMissingSwitchCasesBase(binding, statements, missingEnumCases, preserveOrder); if (missingEnumCases.size() == 0 && hasDefault) return; - createMissingCaseProposalsBase(context, parent, missingEnumCases, proposals); + createMissingCaseProposalsBase(context, parent, missingEnumCases, proposals, preserveOrder); } } @SuppressWarnings("deprecation") - public boolean evaluateMissingSwitchCasesBase(ITypeBinding enumBindings, List switchStatements, ArrayList enumConstNames) { - for (IVariableBinding field : enumBindings.getDeclaredFields()) { + public boolean evaluateMissingSwitchCasesBase(ITypeBinding enumBindings, List switchStatements, ArrayList enumConstNames, boolean preserveOrder) { + IVariableBinding[] declaredFields= Arrays.copyOf(enumBindings.getDeclaredFields(), enumBindings.getDeclaredFields().length); + if (preserveOrder) { + Arrays.sort(declaredFields, new Comparator() { + @Override + public int compare(IVariableBinding o1, IVariableBinding o2) { + return o1.getVariableId() - o2.getVariableId(); + } + }); + } + + for (IVariableBinding field : declaredFields) { if (field.isEnumConstant()) { enumConstNames.add(field.getName()); } @@ -1249,7 +1266,7 @@ public boolean evaluateMissingSwitchCasesBase(ITypeBinding enumBindings, List enumConstNames, Collection proposals) { + public void createMissingCaseProposalsBase(IInvocationContext context, ASTNode parent, ArrayList enumConstNames, Collection proposals, boolean preserveOrder) { List statements; Expression expression; if (parent instanceof SwitchStatement) { @@ -1292,7 +1309,9 @@ public void createMissingCaseProposalsBase(IInvocationContext context, ASTNode p listRewrite= astRewrite.getListRewrite(parent, SwitchExpression.STATEMENTS_PROPERTY); } - String label= CorrectionMessages.LocalCorrectionsSubProcessor_add_missing_cases_description; + String label= preserveOrder ? + CorrectionMessages.LocalCorrectionsSubProcessor_add_missing_cases_description : + CorrectionMessages.LocalCorrectionsSubProcessor_add_missing_cases_description_alphabetical; LinkedCorrectionProposalCore proposal= new LinkedCorrectionProposalCore(label, context.getCompilationUnit(), astRewrite, IProposalRelevance.ADD_MISSING_CASE_STATEMENTS); for (String enumConstName : enumConstNames) { @@ -1357,7 +1376,7 @@ public void createMissingCaseProposalsBase(IInvocationContext context, ASTNode p } proposals.add(linkedCorrectionProposalToT(proposal, ADD_MISSING_CASE)); } - if (!hasDefault) { + if (!hasDefault && !preserveOrder) { createMissingDefaultProposal(context, parent, proposals); } } diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/AssistQuickFixTest.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/AssistQuickFixTest.java index 29a4b86987a..4ecc4639b54 100644 --- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/AssistQuickFixTest.java +++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/AssistQuickFixTest.java @@ -8324,7 +8324,7 @@ public void testMissingEnumConstantsInCase1() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8340,15 +8340,15 @@ public void foo(MyEnum x) { List proposals= collectAssists(context, false); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 4); + assertNumberOfProposals(proposals, 5); - String[] expected= new String[4]; + String[] expected= new String[5]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8362,11 +8362,35 @@ public void foo(MyEnum x) { """; expected[1]= """ + package p; + + public class E { + enum MyEnum { + X3, X2, X1 + } + \s + public void foo(MyEnum x) { + switch (x) { + case X3 : + break; + case X2 : + break; + case X1 : + break; + default : + break; + \s + } + } + } + """; + + expected[2]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8385,12 +8409,12 @@ public void foo(MyEnum x) { } """; - expected[2]= """ + expected[3]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8398,12 +8422,12 @@ public void foo(MyEnum x) { } """; - expected[3]= """ + expected[4]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8426,7 +8450,7 @@ public void testMissingEnumConstantsInCase2() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8444,15 +8468,15 @@ public void foo(MyEnum x) { List proposals= collectAssists(context, false); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 3); + assertNumberOfProposals(proposals, 4); - String[] expected= new String[3]; + String[] expected= new String[4]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8468,11 +8492,35 @@ public void foo(MyEnum x) { """; expected[1]= """ + package p; + + public class E { + enum MyEnum { + X3, X2, X1 + } + \s + public void foo(MyEnum x) { + switch (x) { + case X1 : + break; + case X3 : + break; + case X2 : + break; + default : + break; + \s + } + } + } + """; + + expected[2]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8491,12 +8539,12 @@ public void foo(MyEnum x) { } """; - expected[2]= """ + expected[3]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8517,7 +8565,7 @@ public void testMissingEnumConstantsInCase3() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8535,15 +8583,15 @@ public void foo(MyEnum x) { List proposals= collectAssists(context, false); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 2); + assertNumberOfProposals(proposals, 3); - String[] expected= new String[2]; + String[] expected= new String[3]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8563,17 +8611,17 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { switch (x) { case X1 : break; - case X2 : - break; case X3 : break; + case X2 : + break; default : break; \s @@ -8582,6 +8630,30 @@ public void foo(MyEnum x) { } """; + expected[2]= """ + package p; + + public class E { + enum MyEnum { + X3, X2, X1 + } + \s + public void foo(MyEnum x) { + switch (x) { + case X1 : + break; + case X2 : + break; + case X3 : + break; + default : + break; + \s + } + } + } + """; + assertExpectedExistInProposals(proposals, expected); } @@ -8593,7 +8665,7 @@ public void testMissingEnumConstantsInCase4() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8613,23 +8685,23 @@ public void foo(MyEnum x) { List proposals= collectAssists(context, false); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 1); + assertNumberOfProposals(proposals, 2); - String[] expected= new String[1]; + String[] expected= new String[2]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { switch (x) { case X1 : break; - case X2 : case X3 : + case X2 : default : break; \s @@ -8638,6 +8710,28 @@ public void foo(MyEnum x) { } """; + expected[1]= """ + package p; + + public class E { + enum MyEnum { + X3, X2, X1 + } + \s + public void foo(MyEnum x) { + switch (x) { + case X1 : + break; + case X2 : + case X3 : + default : + break; + \s + } + } + } + """; + assertExpectedExistInProposals(proposals, expected); } @@ -8650,7 +8744,7 @@ public void testMissingEnumConstantsInCase5() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8680,7 +8774,7 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -8704,7 +8798,7 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/LocalCorrectionsQuickFixTest.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/LocalCorrectionsQuickFixTest.java index 6d3748c4508..13b5c37b86d 100644 --- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/LocalCorrectionsQuickFixTest.java +++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/LocalCorrectionsQuickFixTest.java @@ -11927,7 +11927,7 @@ public void testMissingEnumConstantsInCase1() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -11943,15 +11943,15 @@ public void foo(MyEnum x) { ArrayList proposals= collectCorrections(cu, astRoot, 3); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 4); + assertNumberOfProposals(proposals, 5); - String[] expected= new String[3]; + String[] expected= new String[4]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -11969,7 +11969,7 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -11986,7 +11986,7 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -12021,7 +12021,7 @@ public void testMissingEnumConstantsInCase2() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -12038,15 +12038,15 @@ public void foo(MyEnum x) { ArrayList proposals= collectCorrections(cu, astRoot, 2); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 3); + assertNumberOfProposals(proposals, 4); - String[] expected= new String[2]; + String[] expected= new String[3]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -12065,7 +12065,30 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 + } + \s + public void foo(MyEnum x) { + switch (x) { + case X1 : + break; + case X3 : + break; + case X2 : + break; + default : + break; + } + } + } + """; + + expected[2]= """ + package p; + + public class E { + enum MyEnum { + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -12101,7 +12124,7 @@ public void testMissingEnumConstantsInCase3() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -12130,7 +12153,7 @@ public void foo(MyEnum x) { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo(MyEnum x) { @@ -12166,7 +12189,7 @@ public void testMissingEnumConstantsInCase4() throws Exception { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo() { @@ -12185,15 +12208,15 @@ public MyEnum bar() { ArrayList proposals= collectCorrections(cu, astRoot, 3); assertCorrectLabels(proposals); - assertNumberOfProposals(proposals, 4); + assertNumberOfProposals(proposals, 5); - String[] expected= new String[3]; + String[] expected= new String[4]; expected[0]= """ package p; public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo() { @@ -12214,7 +12237,7 @@ public MyEnum bar() { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 } \s public void foo() { @@ -12234,7 +12257,34 @@ public MyEnum bar() { public class E { enum MyEnum { - X1, X2, X3 + X3, X2, X1 + } + \s + public void foo() { + switch (bar()) { + case X3 : + break; + case X2 : + break; + case X1 : + break; + default : + break; + \s + } + } + public MyEnum bar() { + return null; + } + } + """; + + expected[3]= """ + package p; + + public class E { + enum MyEnum { + X3, X2, X1 } \s public void foo() { diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest14.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest14.java index b692cb20ebf..53df2585a61 100644 --- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest14.java +++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest14.java @@ -71,10 +71,10 @@ enum Day { CompilationUnit astRoot= getASTRoot(cu); ArrayList proposals= collectCorrections(cu, astRoot, 2); - assertNumberOfProposals(proposals, 4); + assertNumberOfProposals(proposals, 5); assertCorrectLabels(proposals); - CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(1); + CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(2); String preview= getPreviewContent(proposal); String expected= """ @@ -127,10 +127,10 @@ enum Day { CompilationUnit astRoot= getASTRoot(cu); ArrayList proposals= collectCorrections(cu, astRoot, 2); - assertNumberOfProposals(proposals, 4); + assertNumberOfProposals(proposals, 5); assertCorrectLabels(proposals); - CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(1); + CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(2); String preview= getPreviewContent(proposal); String expected= """ @@ -182,10 +182,10 @@ enum Day { CompilationUnit astRoot= getASTRoot(cu); ArrayList proposals= collectCorrections(cu, astRoot, 7); - assertNumberOfProposals(proposals, 5); + assertNumberOfProposals(proposals, 6); assertCorrectLabels(proposals); - CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(1); + CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(2); String preview= getPreviewContent(proposal); String expected= """ @@ -219,7 +219,7 @@ enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY; } """; - CUCorrectionProposal proposal2= (CUCorrectionProposal) proposals.get(2); + CUCorrectionProposal proposal2= (CUCorrectionProposal) proposals.get(3); String preview2= getPreviewContent(proposal2); assertEqualStringsIgnoreOrder(new String[] { preview2 }, new String[] { expected2 }); @@ -255,10 +255,10 @@ enum Day { CompilationUnit astRoot= getASTRoot(cu); ArrayList proposals= collectCorrections(cu, astRoot, 2); - assertNumberOfProposals(proposals, 4); + assertNumberOfProposals(proposals, 5); assertCorrectLabels(proposals); - CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0); + CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(1); String preview= getPreviewContent(proposal); String expected= """ @@ -480,10 +480,10 @@ enum Day { CompilationUnit astRoot= getASTRoot(cu); ArrayList proposals= collectCorrections(cu, astRoot, 2); - assertNumberOfProposals(proposals, 2); + assertNumberOfProposals(proposals, 3); assertCorrectLabels(proposals); - CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0); + CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(1); String preview= getPreviewContent(proposal); String expected= """ diff --git a/org.eclipse.jdt.ui/META-INF/MANIFEST.MF b/org.eclipse.jdt.ui/META-INF/MANIFEST.MF index 53f1b0d306e..a5dc720767b 100644 --- a/org.eclipse.jdt.ui/META-INF/MANIFEST.MF +++ b/org.eclipse.jdt.ui/META-INF/MANIFEST.MF @@ -3,7 +3,7 @@ Automatic-Module-Name: org.eclipse.jdt.ui Bundle-ManifestVersion: 2 Bundle-Name: %pluginName Bundle-SymbolicName: org.eclipse.jdt.ui; singleton:=true -Bundle-Version: 3.35.100.qualifier +Bundle-Version: 3.35.200.qualifier Bundle-Activator: org.eclipse.jdt.internal.ui.JavaPlugin Bundle-ActivationPolicy: lazy Bundle-Vendor: %providerName diff --git a/org.eclipse.jdt.ui/pom.xml b/org.eclipse.jdt.ui/pom.xml index e81c09a1250..fa432d58f4d 100644 --- a/org.eclipse.jdt.ui/pom.xml +++ b/org.eclipse.jdt.ui/pom.xml @@ -18,7 +18,7 @@ org.eclipse.jdt org.eclipse.jdt.ui - 3.35.100-SNAPSHOT + 3.35.200-SNAPSHOT eclipse-plugin diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java index 0f2b00e5362..b45b1388e66 100644 --- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java +++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java @@ -1148,16 +1148,16 @@ public static void addDeprecatedFieldsToMethodsProposals(IInvocationContext cont new LocalCorrectionsSubProcessor().getDeprecatedFieldsToMethodsProposals(context, problem, proposals); } - public static void getMissingEnumConstantCaseProposals(IInvocationContext context, IProblemLocation problem, Collection proposals) { - new LocalCorrectionsSubProcessor().getMissingEnumConstantCaseProposalsBase(context, problem, proposals); + public static void getMissingEnumConstantCaseProposals(IInvocationContext context, IProblemLocation problem, Collection proposals, boolean preserveOrder) { + new LocalCorrectionsSubProcessor().getMissingEnumConstantCaseProposalsBase(context, problem, proposals, preserveOrder); } - public static boolean evaluateMissingSwitchCases(ITypeBinding enumBindings, List switchStatements, ArrayList enumConstNames) { - return new LocalCorrectionsSubProcessor().evaluateMissingSwitchCasesBase(enumBindings, switchStatements, enumConstNames); + public static boolean evaluateMissingSwitchCases(ITypeBinding enumBindings, List switchStatements, ArrayList enumConstNames, boolean preserveOrder) { + return new LocalCorrectionsSubProcessor().evaluateMissingSwitchCasesBase(enumBindings, switchStatements, enumConstNames, preserveOrder); } - public static void createMissingCaseProposals(IInvocationContext context, ASTNode parent, ArrayList enumConstNames, Collection proposals) { - new LocalCorrectionsSubProcessor().createMissingCaseProposalsBase(context, parent, enumConstNames, proposals); + public static void createMissingCaseProposals(IInvocationContext context, ASTNode parent, ArrayList enumConstNames, Collection proposals, boolean preserveOrder) { + new LocalCorrectionsSubProcessor().createMissingCaseProposalsBase(context, parent, enumConstNames, proposals, preserveOrder); } public static void removeDefaultCaseProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) { diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java index 092098bcdf3..9ab9722bd1b 100644 --- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java +++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java @@ -338,7 +338,8 @@ public boolean hasAssists(IInvocationContext context) throws CoreException { || getFixParenthesesInLambdaExpression(context, coveringNode, null) || getRemoveBlockProposals(context, coveringNode, null) || getMakeVariableDeclarationFinalProposals(context, null) - || getMissingCaseStatementProposals(context, coveringNode, null) + || getMissingCaseStatementProposals(context, coveringNode, null, true) + || getMissingCaseStatementProposals(context, coveringNode, null, false) || ConvertStringConcatenationProposals.getProposals(context, null) || getInferDiamondArgumentsProposal(context, coveringNode, null, null) || getJUnitTestCaseProposal(context, coveringNode, null) @@ -422,7 +423,8 @@ public IJavaCompletionProposal[] getAssists(IInvocationContext context, IProblem getRemoveBlockProposals(context, coveringNode, resultingCollections); getMakeVariableDeclarationFinalProposals(context, resultingCollections); ConvertStringConcatenationProposals.getProposals(context, resultingCollections); - getMissingCaseStatementProposals(context, coveringNode, resultingCollections); + getMissingCaseStatementProposals(context, coveringNode, resultingCollections, true); + getMissingCaseStatementProposals(context, coveringNode, resultingCollections, false); getConvertVarTypeToResolvedTypeProposal(context, coveringNode, resultingCollections); getConvertResolvedTypeToVarTypeProposal(context, coveringNode, resultingCollections); getAddStaticImportProposals(context, coveringNode, resultingCollections); @@ -3218,7 +3220,7 @@ private static boolean getInlineLocalProposal(IInvocationContext context, final return true; } - private static boolean getMissingCaseStatementProposals(IInvocationContext context, ASTNode node, Collection proposals) { + private static boolean getMissingCaseStatementProposals(IInvocationContext context, ASTNode node, Collection proposals, boolean preserveOrder) { if (node instanceof SwitchCase) { node= node.getParent(); } @@ -3231,14 +3233,14 @@ private static boolean getMissingCaseStatementProposals(IInvocationContext conte return false; ArrayList missingEnumCases= new ArrayList<>(); - boolean hasDefault= LocalCorrectionsSubProcessor.evaluateMissingSwitchCases(expressionBinding, switchStatement.statements(), missingEnumCases); + boolean hasDefault= LocalCorrectionsSubProcessor.evaluateMissingSwitchCases(expressionBinding, switchStatement.statements(), missingEnumCases, preserveOrder); if (missingEnumCases.isEmpty() && hasDefault) return false; if (proposals == null) return true; - LocalCorrectionsSubProcessor.createMissingCaseProposals(context, switchStatement, missingEnumCases, proposals); + LocalCorrectionsSubProcessor.createMissingCaseProposals(context, switchStatement, missingEnumCases, proposals, preserveOrder); return true; } diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickFixProcessor.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickFixProcessor.java index 6cc311bd2b4..3ac7204532d 100644 --- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickFixProcessor.java +++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickFixProcessor.java @@ -809,10 +809,13 @@ private void process(IInvocationContext context, IProblemLocation problem, Colle case IProblem.UnusedWarningToken: SuppressWarningsSubProcessor.addRemoveUnusedSuppressWarningProposals(context, problem, proposals); break; - case IProblem.MissingEnumConstantCase: case IProblem.MissingEnumDefaultCase: + LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals, false); + break; + case IProblem.MissingEnumConstantCase: case IProblem.SwitchExpressionsYieldMissingEnumConstantCase: - LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals); + LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals, true); + LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals, false); break; case IProblem.EnhancedSwitchMissingDefault: case IProblem.SwitchExpressionsYieldMissingDefaultCase: @@ -828,7 +831,8 @@ private void process(IInvocationContext context, IProblemLocation problem, Colle LocalCorrectionsSubProcessor.addFallThroughProposals(context, problem, proposals); break; case IProblem.MissingEnumConstantCaseDespiteDefault: - LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals); + LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals, true); + LocalCorrectionsSubProcessor.getMissingEnumConstantCaseProposals(context, problem, proposals, false); LocalCorrectionsSubProcessor.addCasesOmittedProposals(context, problem, proposals); break; case IProblem.MissingSynchronizedModifierInInheritedMethod: