Bug 571077: [16] Merge master branch to BETA_JAVA16 branch after 570855
for Y-builds
Change-Id: I7fc6b429c2065f92637e46eb60e3a321652d57ca
diff --git a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java
index ab7973c..2ed3b55 100644
--- a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java
+++ b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java
@@ -132,6 +132,7 @@
public static String StaticInnerClassCleanUp_description;
public static String StringBuilderCleanUp_description;
public static String CodeStyleCleanUp_LazyLogical_description;
+ public static String PrimitiveComparisonCleanUp_description;
public static String PrimitiveParsingCleanUp_description;
public static String PrimitiveSerializationCleanUp_description;
@@ -140,6 +141,7 @@
public static String HashCleanup_description;
public static String RedundantModifiersCleanup_description;
+ public static String SubstringCleanUp_description;
public static String JoinCleanup_description;
public static String ArraysFillCleanUp_description;
public static String EvaluateNullableCleanUp_description;
@@ -150,6 +152,7 @@
public static String DoubleNegationCleanUp_description;
public static String RedundantComparisonStatementCleanup_description;
public static String RedundantSuperCallCleanup_description;
+ public static String UnreachableBlockCleanUp_description;
public static String TernaryOperatorCleanUp_description;
public static String StrictlyEqualOrDifferentCleanUp_description;
public static String MergeConditionalBlocksCleanup_description;
diff --git a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties
index 4ed57c3..8863cac 100644
--- a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties
+++ b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties
@@ -114,6 +114,7 @@
StaticInnerClassCleanUp_description=Make inner classes static where possible
StringBuilderCleanUp_description=Replace String concatenation by StringBuilder
CodeStyleCleanUp_LazyLogical_description=Use lazy logical operator (&& and ||)
+PrimitiveComparisonCleanUp_description=Primitive comparison
PrimitiveParsingCleanUp_description=Primitive parsing
PrimitiveSerializationCleanUp_description=Primitive serialization
@@ -122,6 +123,7 @@
HashCleanup_description=Use Objects.hash()
RedundantModifiersCleanup_description=Remove redundant modifiers
+SubstringCleanUp_description=Redundant String.substring() parameter
JoinCleanup_description=Use String.join()
ArraysFillCleanUp_description=Use Arrays.fill() when possible
EvaluateNullableCleanUp_description=Evaluate without null check
@@ -132,6 +134,7 @@
DoubleNegationCleanUp_description=Double negation
RedundantComparisonStatementCleanup_description=Remove redundant comparison statement
RedundantSuperCallCleanup_description=Remove redundant super() call in constructor
+UnreachableBlockCleanUp_description=Unreachable block
TernaryOperatorCleanUp_description=Replace (X && Y) || (!X && Z) by X ? Y : Z
StrictlyEqualOrDifferentCleanUp_description=Use '==' or '^' on booleans
MergeConditionalBlocksCleanup_description=Merge conditions of if/else if/else that have the same blocks
diff --git a/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/PrimitiveComparisonCleanUpCore.java b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/PrimitiveComparisonCleanUpCore.java
new file mode 100644
index 0000000..619d0b3
--- /dev/null
+++ b/org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/PrimitiveComparisonCleanUpCore.java
@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Fabrice TIERCELIN and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Fabrice TIERCELIN - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.fix;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.manipulation.CleanUpContextCore;
+import org.eclipse.jdt.core.manipulation.CleanUpRequirementsCore;
+import org.eclipse.jdt.core.manipulation.ICleanUpFixCore;
+
+import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
+import org.eclipse.jdt.internal.corext.fix.PrimitiveComparisonFixCore;
+
+public class PrimitiveComparisonCleanUpCore extends AbstractCleanUpCore {
+ public PrimitiveComparisonCleanUpCore(final Map<String, String> options) {
+ super(options);
+ }
+
+ public PrimitiveComparisonCleanUpCore() {
+ }
+
+ @Override
+ public CleanUpRequirementsCore getRequirementsCore() {
+ return new CleanUpRequirementsCore(requireAST(), false, false, null);
+ }
+
+ public boolean requireAST() {
+ return isEnabled(CleanUpConstants.PRIMITIVE_COMPARISON);
+ }
+
+ @Override
+ public ICleanUpFixCore createFixCore(final CleanUpContextCore context) throws CoreException {
+ CompilationUnit compilationUnit= context.getAST();
+
+ if (compilationUnit == null || !isEnabled(CleanUpConstants.PRIMITIVE_COMPARISON)) {
+ return null;
+ }
+
+ return PrimitiveComparisonFixCore.createCleanUp(compilationUnit);
+ }
+
+ @Override
+ public String[] getStepDescriptions() {
+ List<String> result= new ArrayList<>();
+
+ if (isEnabled(CleanUpConstants.PRIMITIVE_COMPARISON)) {
+ result.add(MultiFixMessages.PrimitiveComparisonCleanUp_description);
+ }
+
+ return result.toArray(new String[0]);
+ }
+
+ @Override
+ public String getPreview() {
+ if (isEnabled(CleanUpConstants.PRIMITIVE_COMPARISON)) {
+ return "int comparison = Integer.compare(number, anotherNumber);"; //$NON-NLS-1$
+ }
+
+ return "int comparison = Integer.valueOf(number).compareTo(anotherNumber);"; //$NON-NLS-1$
+ }
+}
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/codemanipulation/StubUtility2Core.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/codemanipulation/StubUtility2Core.java
index f731148..178019f 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/codemanipulation/StubUtility2Core.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/codemanipulation/StubUtility2Core.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2018, 2019 IBM Corporation and others.
+ * Copyright (c) 2018, 2021 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
@@ -761,7 +761,7 @@
IMethodBinding[] typeMethods= typeBinding.getDeclaredMethods();
for (IMethodBinding typeMethod : typeMethods) {
final int modifiers= typeMethod.getModifiers();
- if (!typeMethod.isConstructor() && !Modifier.isStatic(modifiers) && !Modifier.isPrivate(modifiers)) {
+ if (!typeMethod.isConstructor() && !Modifier.isStatic(modifiers) && !Modifier.isPrivate(modifiers) && !typeMethod.isSyntheticRecordMethod()) {
allMethods.add(typeMethod);
}
}
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java
index 3ca898c..6e8b13c 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java
@@ -762,6 +762,18 @@
public static final String USE_LAZY_LOGICAL_OPERATOR= "cleanup.lazy_logical_operator"; //$NON-NLS-1$
/**
+ * Replaces the <code>compareTo()</code> method by a comparison on primitive.
+ * <p>
+ * Possible values: {TRUE, FALSE}
+ * <p>
+ *
+ * @see CleanUpOptionsCore#TRUE
+ * @see CleanUpOptionsCore#FALSE
+ * @since 4.19
+ */
+ public static final String PRIMITIVE_COMPARISON= "cleanup.primitive_comparison"; //$NON-NLS-1$
+
+ /**
* Avoids to create primitive wrapper when parsing a string.
* <p>
* Possible values: {TRUE, FALSE}
@@ -1250,6 +1262,18 @@
public static final String REMOVE_REDUNDANT_MODIFIERS= "cleanup.remove_redundant_modifiers"; //$NON-NLS-1$
/**
+ * Removes the second <code>substring()</code> parameter if this parameter is the length of the string.
+ * <p>
+ * Possible values: {TRUE, FALSE}
+ * <p>
+ *
+ * @see CleanUpOptionsCore#TRUE
+ * @see CleanUpOptionsCore#FALSE
+ * @since 4.19
+ */
+ public static final String SUBSTRING= "cleanup.substring"; //$NON-NLS-1$
+
+ /**
* Replaces for loops to use String.join() where possible.
* <p>
* Possible values: {TRUE, FALSE}
@@ -1370,6 +1394,18 @@
public static final String REDUNDANT_SUPER_CALL= "cleanup.no_super"; //$NON-NLS-1$
/**
+ * Detect two successive <code>if</code> conditions that are identical and remove the second one.
+ * <p>
+ * Possible values: {TRUE, FALSE}
+ * <p>
+ *
+ * @see CleanUpOptionsCore#TRUE
+ * @see CleanUpOptionsCore#FALSE
+ * @since 4.19
+ */
+ public static final String UNREACHABLE_BLOCK= "cleanup.unreachable_block"; //$NON-NLS-1$
+
+ /**
* Replaces (X && Y) || (!X && Z) by X ? Y : Z.
* <p>
* Possible values: {TRUE, FALSE}
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java
index bcbb703..8c2070f 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java
@@ -58,6 +58,7 @@
public static String ConvertIterableLoopOperation_semanticChangeWarning;
public static String ExpressionsFix_add_parentheses_change_name;
public static String ExpressionsFix_remove_parentheses_change_name;
+ public static String PrimitiveComparisonFix_convert_compareTo_to_primitive_comparison;
public static String ImportsFix_OrganizeImports_Description;
public static String Java50Fix_add_annotations_change_name;
public static String Java50Fix_add_type_parameters_change_name;
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties
index b463869..7cafc29 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties
@@ -105,6 +105,8 @@
ConvertIterableLoopOperation_RemoveUpdateExpressions_Warning=The expressions in the update part of the loop will be removed.
ImportsFix_OrganizeImports_Description=Organize Imports
+PrimitiveComparisonFix_convert_compareTo_to_primitive_comparison=Convert compareTo() method to a primitive comparison
+
CleanUpPostSaveListener_name=Code Clean Up
CleanUpPostSaveListener_SaveAction_ChangeName=Save Actions
CleanUpPostSaveListener_SlowCleanUpDialog_link=If this happens again we recommend to disable the corresponding save actions on the <a>'Save Actions'</a> preference page.
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveComparisonFixCore.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveComparisonFixCore.java
new file mode 100644
index 0000000..638148f
--- /dev/null
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveComparisonFixCore.java
@@ -0,0 +1,152 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Fabrice TIERCELIN and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Fabrice TIERCELIN - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.corext.fix;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.text.edits.TextEditGroup;
+
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.CastExpression;
+import org.eclipse.jdt.core.dom.ClassInstanceCreation;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.MethodInvocation;
+import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
+import org.eclipse.jdt.core.manipulation.ICleanUpFixCore;
+
+import org.eclipse.jdt.internal.corext.dom.ASTNodes;
+import org.eclipse.jdt.internal.corext.dom.Bindings;
+import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
+
+import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
+
+public class PrimitiveComparisonFixCore extends CompilationUnitRewriteOperationsFixCore {
+ public static final class PrimitiveComparisonFinder extends ASTVisitor {
+ private List<PrimitiveComparisonFixOperation> fResult;
+
+ public PrimitiveComparisonFinder(List<PrimitiveComparisonFixOperation> ops) {
+ fResult= ops;
+ }
+
+ @Override
+ public boolean visit(final MethodInvocation visited) {
+ if (visited.getExpression() != null
+ && visited.arguments().size() == 1) {
+ Class<?>[] wrapperClasses= { Integer.class, Boolean.class, Long.class, Double.class, Character.class, Float.class, Short.class, Byte.class };
+
+ for (Class<?> wrapperClass : wrapperClasses) {
+ String canonicalName= wrapperClass.getCanonicalName();
+ String primitiveName= Bindings.getUnboxedTypeName(canonicalName);
+
+ if (ASTNodes.isPrimitive((Expression) visited.arguments().get(0), primitiveName)
+ && ASTNodes.usesGivenSignature(visited, canonicalName, "compareTo", canonicalName)) { //$NON-NLS-1$
+ MethodInvocation methodInvocation = ASTNodes.as(visited.getExpression(), MethodInvocation.class);
+
+ if (methodInvocation != null
+ && ASTNodes.usesGivenSignature(methodInvocation, canonicalName, "valueOf", primitiveName) //$NON-NLS-1$
+ && ASTNodes.isPrimitive((Expression) methodInvocation.arguments().get(0), primitiveName)) {
+ fResult.add(new PrimitiveComparisonFixOperation(visited, (Expression) methodInvocation.arguments().get(0), wrapperClass));
+ return false;
+ }
+
+ ClassInstanceCreation classInstanceCreation = ASTNodes.as(visited.getExpression(), ClassInstanceCreation.class);
+
+ if (classInstanceCreation != null
+ && ASTNodes.hasType(classInstanceCreation.getType().resolveBinding(), canonicalName)
+ && ASTNodes.isPrimitive((Expression) classInstanceCreation.arguments().get(0), primitiveName)) {
+ fResult.add(new PrimitiveComparisonFixOperation(visited, (Expression) classInstanceCreation.arguments().get(0), wrapperClass));
+ return false;
+ }
+
+ CastExpression castExpression = ASTNodes.as(visited.getExpression(), CastExpression.class);
+
+ if (castExpression != null
+ && ASTNodes.hasType(castExpression.getType().resolveBinding(), canonicalName)
+ && ASTNodes.isPrimitive(castExpression.getExpression(), primitiveName)) {
+ fResult.add(new PrimitiveComparisonFixOperation(visited, castExpression.getExpression(), wrapperClass));
+ return false;
+ }
+
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+ }
+
+ public static class PrimitiveComparisonFixOperation extends CompilationUnitRewriteOperation {
+ private final MethodInvocation visited;
+ private final Expression primitiveValue;
+ private final Class<?> wrapperClass;
+
+ public PrimitiveComparisonFixOperation(final MethodInvocation visited, final Expression primitiveValue, final Class<?> wrapperClass) {
+ this.visited= visited;
+ this.primitiveValue= primitiveValue;
+ this.wrapperClass= wrapperClass;
+ }
+
+ @Override
+ public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModelCore linkedModel) throws CoreException {
+ ASTRewrite rewrite= cuRewrite.getASTRewrite();
+ AST ast= cuRewrite.getRoot().getAST();
+ TextEditGroup group= createTextEditGroup(MultiFixMessages.PrimitiveComparisonCleanUp_description, cuRewrite);
+ rewrite.setTargetSourceRangeComputer(new TargetSourceRangeComputer() {
+ @Override
+ public SourceRange computeSourceRange(final ASTNode nodeWithComment) {
+ if (Boolean.TRUE.equals(nodeWithComment.getProperty(ASTNodes.UNTOUCH_COMMENT))) {
+ return new SourceRange(nodeWithComment.getStartPosition(), nodeWithComment.getLength());
+ }
+
+ return super.computeSourceRange(nodeWithComment);
+ }
+ });
+
+
+ MethodInvocation compareMethod= ast.newMethodInvocation();
+ compareMethod.setExpression(ast.newSimpleName(wrapperClass.getSimpleName()));
+ compareMethod.setName(ast.newSimpleName("compare")); //$NON-NLS-1$
+ compareMethod.arguments().add(ASTNodes.createMoveTarget(rewrite, ASTNodes.getUnparenthesedExpression(primitiveValue)));
+ compareMethod.arguments().add(ASTNodes.createMoveTarget(rewrite, ASTNodes.getUnparenthesedExpression((Expression) visited.arguments().get(0))));
+
+ ASTNodes.replaceButKeepComment(rewrite, visited, compareMethod, group);
+ }
+ }
+
+
+ public static ICleanUpFixCore createCleanUp(final CompilationUnit compilationUnit) {
+ List<PrimitiveComparisonFixOperation> operations= new ArrayList<>();
+ PrimitiveComparisonFinder finder= new PrimitiveComparisonFinder(operations);
+ compilationUnit.accept(finder);
+
+ if (operations.isEmpty()) {
+ return null;
+ }
+
+ CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[] ops= operations.toArray(new CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[0]);
+ return new PrimitiveComparisonFixCore(FixMessages.PrimitiveComparisonFix_convert_compareTo_to_primitive_comparison, compilationUnit, ops);
+ }
+
+ protected PrimitiveComparisonFixCore(final String name, final CompilationUnit compilationUnit, final CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[] fixRewriteOperations) {
+ super(name, compilationUnit, fixRewriteOperations);
+ }
+}
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/refactoring/code/flow/FlowAnalyzer.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/refactoring/code/flow/FlowAnalyzer.java
index 6c0e99b..5f8d49d 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/refactoring/code/flow/FlowAnalyzer.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/refactoring/code/flow/FlowAnalyzer.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corporation and others.
+ * Copyright (c) 2000, 2021 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
@@ -49,6 +49,7 @@
import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.ExpressionMethodReference;
import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.FieldDeclaration;
@@ -1070,6 +1071,9 @@
MessageSendFlowInfo info= createMessageSendFlowInfo();
setFlowInfo(node, info);
for (Expression arg : arguments) {
+ if (arg instanceof ExpressionMethodReference) {
+ arg= ((ExpressionMethodReference)arg).getExpression();
+ }
info.mergeArgument(getFlowInfo(arg), fFlowContext);
}
info.mergeReceiver(getFlowInfo(receiver), fFlowContext);
diff --git a/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitPlugin.java b/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitPlugin.java
index 09feb5c..2350794 100644
--- a/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitPlugin.java
+++ b/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitPlugin.java
@@ -78,8 +78,6 @@
private BundleContext fBundleContext;
- private static boolean fIsStopped= false;
-
public JUnitPlugin() {
fgPlugin= this;
@@ -250,7 +248,6 @@
@Override
public void stop(BundleContext context) throws Exception {
- fIsStopped= true;
super.stop(context);
fBundleContext= null;
}
@@ -332,10 +329,6 @@
return null;
}
- public static boolean isStopped() {
- return fIsStopped;
- }
-
public IDialogSettings getDialogSettingsSection(String name) {
IDialogSettings dialogSettings= getDialogSettings();
IDialogSettings section= dialogSettings.getSection(name);
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/lambdaExpression18_in/A_test327.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/lambdaExpression18_in/A_test327.java
new file mode 100644
index 0000000..e62aabb
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/lambdaExpression18_in/A_test327.java
@@ -0,0 +1,13 @@
+package lambdaExpression18_in;
+
+import java.util.List;
+
+public class C1 {
+ void doIt() {
+ List<String> list= List.of("a", "b");
+ String search = "b";
+
+ /*[*/final boolean isFound = list.stream()
+ .anyMatch(search::equals);/*]*/
+ }
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/lambdaExpression18_out/A_test327.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/lambdaExpression18_out/A_test327.java
new file mode 100644
index 0000000..034c6af
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/lambdaExpression18_out/A_test327.java
@@ -0,0 +1,17 @@
+package lambdaExpression18_in;
+
+import java.util.List;
+
+public class C1 {
+ void doIt() {
+ List<String> list= List.of("a", "b");
+ String search = "b";
+
+ extracted(list, search);
+ }
+
+ private void extracted(List<String> list, String search) {
+ /*[*/final boolean isFound = list.stream()
+ .anyMatch(search::equals);/*]*/
+ }
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests1d8.java b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests1d8.java
index e2bdf96..88702f9 100644
--- a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests1d8.java
+++ b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests1d8.java
@@ -321,4 +321,10 @@
public void test326() throws Exception {
lambdaExpressionTest(0, Modifier.PUBLIC);
}
+
+ @Test
+ public void test327() throws Exception {
+ lambdaExpressionTest(0, Modifier.PRIVATE);
+ }
+
}
diff --git a/org.eclipse.jdt.ui.tests/performance/org/eclipse/jdt/ui/tests/performance/views/CleanUpPerfTest.java b/org.eclipse.jdt.ui.tests/performance/org/eclipse/jdt/ui/tests/performance/views/CleanUpPerfTest.java
index d5da16f..3457153 100644
--- a/org.eclipse.jdt.ui.tests/performance/org/eclipse/jdt/ui/tests/performance/views/CleanUpPerfTest.java
+++ b/org.eclipse.jdt.ui.tests/performance/org/eclipse/jdt/ui/tests/performance/views/CleanUpPerfTest.java
@@ -82,6 +82,7 @@
import org.eclipse.jdt.internal.ui.fix.LazyLogicalCleanUp;
import org.eclipse.jdt.internal.ui.fix.MapCloningCleanUp;
import org.eclipse.jdt.internal.ui.fix.MergeConditionalBlocksCleanUp;
+import org.eclipse.jdt.internal.ui.fix.PrimitiveComparisonCleanUp;
import org.eclipse.jdt.internal.ui.fix.ReduceIndentationCleanUp;
import org.eclipse.jdt.internal.ui.fix.SingleUsedFieldCleanUp;
import org.eclipse.jdt.internal.ui.fix.SortMembersCleanUp;
@@ -749,6 +750,22 @@
}
@Test
+ public void testPrimitiveComparisonCleanUp() throws Exception {
+ CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();
+ addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());
+
+ Map<String, String> node= getNullSettings();
+
+ node.put(CleanUpConstants.PRIMITIVE_COMPARISON, CleanUpOptions.TRUE);
+
+ storeSettings(node);
+
+ cleanUpRefactoring.addCleanUp(new PrimitiveComparisonCleanUp());
+
+ doCleanUp(cleanUpRefactoring);
+ }
+
+ @Test
public void testMapCloningCleanUp() throws Exception {
CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();
addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());
diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java
index 4393330..65d5516 100644
--- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java
+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java
@@ -4131,6 +4131,93 @@
}
@Test
+ public void testSubstring() throws Exception {
+ IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
+ String given= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " private String textInInstance = \"foo\";\n" //
+ + "\n" //
+ + " public String reduceSubstring(String text) {\n" //
+ + " // Keep this comment\n" //
+ + " return text.substring(2, text.length());\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String reduceSubstringOnField() {\n" //
+ + " // Keep this comment\n" //
+ + " return textInInstance.substring(3, textInInstance.length());\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String reduceSubstringOnExpression(String text) {\n" //
+ + " // Keep this comment\n" //
+ + " return (textInInstance + text).substring(4, (textInInstance + text).length());\n" //
+ + " }\n" //
+ + "}\n";
+ ICompilationUnit cu= pack.createCompilationUnit("E.java", given, false, null);
+
+ enable(CleanUpConstants.SUBSTRING);
+
+ String expected= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " private String textInInstance = \"foo\";\n" //
+ + "\n" //
+ + " public String reduceSubstring(String text) {\n" //
+ + " // Keep this comment\n" //
+ + " return text.substring(2);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String reduceSubstringOnField() {\n" //
+ + " // Keep this comment\n" //
+ + " return textInInstance.substring(3);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String reduceSubstringOnExpression(String text) {\n" //
+ + " // Keep this comment\n" //
+ + " return (textInInstance + text).substring(4);\n" //
+ + " }\n" //
+ + "}\n";
+
+ assertNotEquals("The class must be changed", given, expected);
+ assertGroupCategoryUsed(new ICompilationUnit[] { cu }, new HashSet<>(Arrays.asList(MultiFixMessages.SubstringCleanUp_description)));
+ assertRefactoringResultAsExpected(new ICompilationUnit[] { cu }, new String[] { expected });
+ }
+
+ @Test
+ public void testKeepSubstring() throws Exception {
+ IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
+ String sample= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "import java.util.List;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public String doNotReduceSubstringOnOtherExpression(String text) {\n" //
+ + " return text.substring(5, text.hashCode());\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String doNotReduceSubstringOnConstant(String text) {\n" //
+ + " return text.substring(6, 123);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String doNotReduceSubstringOnDifferentVariable(String text1, String text2) {\n" //
+ + " return text1.substring(7, text2.length());\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String doNotReduceSubstringOnActiveExpression(List<String> texts) {\n" //
+ + " return texts.remove(0).substring(7, texts.remove(0).length());\n" //
+ + " }\n" //
+ + "}\n";
+ ICompilationUnit cu= pack.createCompilationUnit("E.java", sample, false, null);
+
+ enable(CleanUpConstants.SUBSTRING);
+
+ assertRefactoringHasNoChange(new ICompilationUnit[] { cu });
+ }
+
+ @Test
public void testUseArraysFill() throws Exception {
IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
String input= "" //
@@ -4669,6 +4756,160 @@
}
@Test
+ public void testPrimitiveComparison() throws Exception {
+ // Given
+ IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
+ String given= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public int simplifyIntegerComparison(int number, int anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Integer.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyDoubleComparison(double number, double anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Double.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyFloatComparison(float number, float anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Float.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyShortComparison(short number, short anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Short.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyLongComparison(long number, long anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Long.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyCharacterComparison(char number, char anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Character.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyByteComparison(byte number, byte anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Byte.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyBooleanComparison(boolean number, boolean anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Boolean.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int refactorIntegerInstantiation(int number, int anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return new Integer(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int refactorIntegerCast(int number, int anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return ((Integer) number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "}\n";
+
+ String expected= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public int simplifyIntegerComparison(int number, int anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Integer.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyDoubleComparison(double number, double anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Double.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyFloatComparison(float number, float anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Float.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyShortComparison(short number, short anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Short.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyLongComparison(long number, long anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Long.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyCharacterComparison(char number, char anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Character.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyByteComparison(byte number, byte anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Byte.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int simplifyBooleanComparison(boolean number, boolean anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Boolean.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int refactorIntegerInstantiation(int number, int anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Integer.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int refactorIntegerCast(int number, int anotherNumber) {\n" //
+ + " // Keep this comment\n" //
+ + " return Integer.compare(number, anotherNumber);\n" //
+ + " }\n" //
+ + "}\n";
+
+ // When
+ ICompilationUnit cu= pack.createCompilationUnit("E.java", given, false, null);
+ enable(CleanUpConstants.PRIMITIVE_COMPARISON);
+
+ // Then
+ assertNotEquals("The class must be changed", given, expected);
+ assertGroupCategoryUsed(new ICompilationUnit[] { cu }, new HashSet<>(Arrays.asList(MultiFixMessages.PrimitiveComparisonCleanUp_description)));
+ assertRefactoringResultAsExpected(new ICompilationUnit[] { cu }, new String[] { expected });
+ }
+
+ @Test
+ public void testDoNotUsePrimitiveComparison() throws Exception {
+ IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
+ String sample= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public int doNotRefactorWrapper(Integer number, int anotherNumber) {\n" //
+ + " return Integer.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRefactorWrapperComparator(int number, Integer anotherNumber) {\n" //
+ + " return Integer.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRefactorString(String number, int anotherNumber) {\n" //
+ + " return Integer.valueOf(number).compareTo(anotherNumber);\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRefactorBadMethod(int number, int anotherNumber) {\n" //
+ + " return Integer.valueOf(number).valueOf(anotherNumber);\n" //
+ + " }\n" //
+ + "}\n";
+ ICompilationUnit cu= pack.createCompilationUnit("E.java", sample, false, null);
+
+ enable(CleanUpConstants.PRIMITIVE_COMPARISON);
+
+ assertRefactoringHasNoChange(new ICompilationUnit[] { cu });
+ }
+
+ @Test
public void testPrimitiveParsing() throws Exception {
// Given
IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
@@ -6877,6 +7118,315 @@
}
@Test
+ public void testUnreachableBlock() throws Exception {
+ // Given
+ IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
+ String given= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "import java.io.IOException;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public int removeDuplicateCondition(boolean isValid, boolean isFound) {\n" //
+ + " // Keep this comment\n" //
+ + " if (isValid && isFound) {\n" //
+ + " return 0;\n" //
+ + " } else if (isFound && isValid) {\n" //
+ + " return 1;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithElse(int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (i2 > i1) {\n" //
+ + " return 1;\n" //
+ + " } else {\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithSeveralConditions(boolean isActive, int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (isActive) {\n" //
+ + " return 1;\n" //
+ + " } else if (i2 > i1) {\n" //
+ + " return 2;\n" //
+ + " } else {\n" //
+ + " return 3;\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithFollowingCode(boolean isActive, int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (isActive) {\n" //
+ + " return 1;\n" //
+ + " } else if (i2 > i1) {\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 3;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithoutFallingThrough(boolean isActive, int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (isActive) {\n" //
+ + " System.out.println(\"I do not fall through\");\n" //
+ + " } else if (i2 > i1) {\n" //
+ + " System.out.println(\"I do not fall through too\");\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 3;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionAmongOthers(int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 == 0) {\n" //
+ + " return -1;\n" //
+ + " } else if (i1 < i2 + 1) {\n" //
+ + " return 0;\n" //
+ + " } else if (1 + i2 > i1) {\n" //
+ + " return 1;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public void removeDuplicateConditionWithoutUnreachableCode(boolean isActive, boolean isFound) {\n" //
+ + " // Keep this comment\n" //
+ + " if (isActive && isFound) {\n" //
+ + " System.out.println(\"I fall through\");\n" //
+ + " return;\n" //
+ + " } else if (isFound && isActive) {\n" //
+ + " System.out.println(\"I do not fall through\");\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeUncaughtCode(boolean b1, boolean b2) throws IOException {\n" //
+ + " try {\n" //
+ + " // Keep this comment\n" //
+ + " if (b1 && b2) {\n" //
+ + " return 0;\n" //
+ + " } else if (b2 && b1) {\n" //
+ + " throw new IOException();\n" //
+ + " }\n" //
+ + " } catch (NullPointerException e) {\n" //
+ + " System.out.println(\"I should be reachable\");\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "}\n";
+
+ String expected= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "import java.io.IOException;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public int removeDuplicateCondition(boolean isValid, boolean isFound) {\n" //
+ + " // Keep this comment\n" //
+ + " if (isValid && isFound) {\n" //
+ + " return 0;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithElse(int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else {\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithSeveralConditions(boolean isActive, int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (isActive) {\n" //
+ + " return 1;\n" //
+ + " } else {\n" //
+ + " return 3;\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithFollowingCode(boolean isActive, int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (isActive) {\n" //
+ + " return 1;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 3;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionWithoutFallingThrough(boolean isActive, int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 < i2) {\n" //
+ + " return 0;\n" //
+ + " } else if (isActive) {\n" //
+ + " System.out.println(\"I do not fall through\");\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 3;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeDuplicateConditionAmongOthers(int i1, int i2) {\n" //
+ + " // Keep this comment\n" //
+ + " if (i1 == 0) {\n" //
+ + " return -1;\n" //
+ + " } else if (i1 < i2 + 1) {\n" //
+ + " return 0;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public void removeDuplicateConditionWithoutUnreachableCode(boolean isActive, boolean isFound) {\n" //
+ + " // Keep this comment\n" //
+ + " if (isActive && isFound) {\n" //
+ + " System.out.println(\"I fall through\");\n" //
+ + " return;\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int removeUncaughtCode(boolean b1, boolean b2) throws IOException {\n" //
+ + " try {\n" //
+ + " // Keep this comment\n" //
+ + " if (b1 && b2) {\n" //
+ + " return 0;\n" //
+ + " }\n" //
+ + " } catch (NullPointerException e) {\n" //
+ + " System.out.println(\"I should be reachable\");\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "}\n";
+
+ // When
+ ICompilationUnit cu= pack.createCompilationUnit("E.java", given, false, null);
+ enable(CleanUpConstants.UNREACHABLE_BLOCK);
+
+ // Then
+ assertNotEquals("The class must be changed", given, expected);
+ assertGroupCategoryUsed(new ICompilationUnit[] { cu }, new HashSet<>(Arrays.asList(MultiFixMessages.UnreachableBlockCleanUp_description)));
+ assertRefactoringResultAsExpected(new ICompilationUnit[] { cu }, new String[] { expected });
+ }
+
+ @Test
+ public void testKeepUnreachableBlock() throws Exception {
+ IPackageFragment pack= fSourceFolder.createPackageFragment("test1", false, null);
+ String sample= "" //
+ + "package test1;\n" //
+ + "\n" //
+ + "import java.io.IOException;\n" //
+ + "import java.util.List;\n" //
+ + "\n" //
+ + "public class E {\n" //
+ + " public String doNotCreateUnreachable(int i1, int i2) {\n" //
+ + " if (i1 < i2) {\n" //
+ + " return \"Falls through\";\n" //
+ + " } else if (i2 > i1) {\n" //
+ + " System.out.println(\"Does not fall through\");\n" //
+ + " } else {\n" //
+ + " return \"Falls through too\";\n" //
+ + " }\n" //
+ + "\n" //
+ + " return \"I should be reachable\";\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String doNotCreateUnreachableOverSeveralConditions(boolean isEnabled, int i1, int i2) {\n" //
+ + " if (i1 < i2) {\n" //
+ + " return \"Falls through\";\n" //
+ + " } else if (isEnabled) {\n" //
+ + " return \"Falls through too\";\n" //
+ + " } else if (i2 > i1) {\n" //
+ + " System.out.println(\"Does not fall through\");\n" //
+ + " } else {\n" //
+ + " return \"Falls through also\";\n" //
+ + " }\n" //
+ + "\n" //
+ + " return \"I should be reachable\";\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRemoveDifferentCondition(boolean b1, boolean b2) {\n" //
+ + " if (b1 && b2) {\n" //
+ + " return 0;\n" //
+ + " } else if (b2 || b1) {\n" //
+ + " return 1;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRemoveActiveCondition(List<String> myList) {\n" //
+ + " if (myList.remove(\"I will be removed\")) {\n" //
+ + " return 0;\n" //
+ + " } else if (myList.remove(\"I will be removed\")) {\n" //
+ + " return 1;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public String doNotRemoveConditionPrecededByActiveCondition(int number) {\n" //
+ + " if (number > 0) {\n" //
+ + " return \"Falls through\";\n" //
+ + " } else if (number++ == 42) {\n" //
+ + " return \"Active condition\";\n" //
+ + " } else if (number > 0) {\n" //
+ + " return \"Falls through too\";\n" //
+ + " } else {\n" //
+ + " return \"Falls through also\";\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRemoveCaughtCode(boolean b1, boolean b2) {\n" //
+ + " try {\n" //
+ + " if (b1 && b2) {\n" //
+ + " return 0;\n" //
+ + " } else if (b2 && b1) {\n" //
+ + " throw new IOException();\n" //
+ + " }\n" //
+ + " } catch (IOException e) {\n" //
+ + " System.out.println(\"I should be reachable\");\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "\n" //
+ + " public int doNotRemoveThrowingExceptionCode(boolean isValid, int number) {\n" //
+ + " if (isValid || true) {\n" //
+ + " return 0;\n" //
+ + " } else if (isValid || true || ((number / 0) == 42)) {\n" //
+ + " return 1;\n" //
+ + " }\n" //
+ + "\n" //
+ + " return 2;\n" //
+ + " }\n" //
+ + "}\n";
+ ICompilationUnit cu= pack.createCompilationUnit("E.java", sample, false, null);
+
+ enable(CleanUpConstants.UNREACHABLE_BLOCK);
+
+ assertRefactoringHasNoChange(new ICompilationUnit[] { cu });
+ }
+
+ @Test
public void testMergeConditionalBlocks() throws Exception {
IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
String sample= "" //
@@ -13918,6 +14468,8 @@
String sample= "" //
+ "package test1;\n" //
+ "\n" //
+ + "import java.sql.DriverPropertyInfo;\n" //
+ + "\n" //
+ "public class E {\n" //
+ " public interface DoNotRefactorInnerInterface {\n" //
+ " boolean anotherMethod();\n" //
@@ -13931,6 +14483,18 @@
+ " }\n" //
+ " }\n" //
+ "\n" //
+ + " public class DoNotRefactorClassUsingInheritedMemberAsItSNotHandledYet extends DriverPropertyInfo {\n" //
+ + " private static final long serialVersionUID = 1L;\n" //
+ + "\n" //
+ + " public DoNotRefactorClassUsingInheritedMemberAsItSNotHandledYet() {\n" //
+ + " super(\"\", \"\");\n" //
+ + " }\n" //
+ + "\n" //
+ + " public boolean itSNotHandledYet() {\n" //
+ + " return choices != null;\n" //
+ + " }\n" //
+ + " }\n" //
+ + "\n" //
+ " public class DoNotRefactorInnerClassThatUsesMethod {\n" //
+ " int i;\n" //
+ "\n" //
diff --git a/org.eclipse.jdt.ui.unittest.junit.feature/forceQualifierUpdate.txt b/org.eclipse.jdt.ui.unittest.junit.feature/forceQualifierUpdate.txt
new file mode 100644
index 0000000..51c07ff
--- /dev/null
+++ b/org.eclipse.jdt.ui.unittest.junit.feature/forceQualifierUpdate.txt
@@ -0,0 +1,2 @@
+# To force a version qualifier update add the bug here
+Bug 570855 - Include org.eclipse.jdt.ui.unittest.junit.feature in p2 site
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.unittest.junit.feature/pom.xml b/org.eclipse.jdt.ui.unittest.junit.feature/pom.xml
index 4f9eed7..f9bb14b 100644
--- a/org.eclipse.jdt.ui.unittest.junit.feature/pom.xml
+++ b/org.eclipse.jdt.ui.unittest.junit.feature/pom.xml
@@ -22,4 +22,36 @@
<artifactId>org.eclipse.jdt.ui.unittest.junit.feature</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>eclipse-feature</packaging>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-source-plugin</artifactId>
+ <version>${tycho.version}</version>
+ <executions>
+ <execution>
+ <phase>package</phase>
+ <id>feature-source</id>
+ <goals>
+ <goal>feature-source</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.eclipse.tycho</groupId>
+ <artifactId>tycho-p2-plugin</artifactId>
+ <version>${tycho.version}</version>
+ <executions>
+ <execution>
+ <id>attach-p2-metadata</id>
+ <phase>package</phase>
+ <goals>
+ <goal>p2-metadata</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
</project>
diff --git a/org.eclipse.jdt.ui/.settings/.api_filters b/org.eclipse.jdt.ui/.settings/.api_filters
index 0a4cd5e..40dac27 100644
--- a/org.eclipse.jdt.ui/.settings/.api_filters
+++ b/org.eclipse.jdt.ui/.settings/.api_filters
@@ -24,6 +24,13 @@
<message_argument value="isRecordComponent()"/>
</message_arguments>
</filter>
+ <filter comment="Java 15 preview feature" id="640712815">
+ <message_arguments>
+ <message_argument value="IMethodBinding"/>
+ <message_argument value="RefactoringAvailabilityTester"/>
+ <message_argument value="isCanonicalConstructor()"/>
+ </message_arguments>
+ </filter>
</resource>
<resource path="core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/IntroduceFactoryRefactoring.java" type="org.eclipse.jdt.internal.corext.refactoring.code.IntroduceFactoryRefactoring">
<filter comment="This is a Java 15 preview feature" id="640712815">
@@ -364,6 +371,15 @@
</message_arguments>
</filter>
</resource>
+ <resource path="ui/org/eclipse/jdt/ui/actions/GenerateNewConstructorUsingFieldsAction.java" type="org.eclipse.jdt.ui.actions.GenerateNewConstructorUsingFieldsAction">
+ <filter comment="This is a Java15 preview feature" id="640712815">
+ <message_arguments>
+ <message_argument value="IType"/>
+ <message_argument value="GenerateNewConstructorUsingFieldsAction"/>
+ <message_argument value="isRecord()"/>
+ </message_arguments>
+ </filter>
+ </resource>
<resource path="ui/org/eclipse/jdt/ui/actions/IJavaEditorActionDefinitionIds.java" type="org.eclipse.jdt.ui.actions.IJavaEditorActionDefinitionIds">
<filter id="571473929">
<message_arguments>
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstantsOptions.java b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstantsOptions.java
index 38abe1a..41c5716 100644
--- a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstantsOptions.java
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstantsOptions.java
@@ -53,7 +53,6 @@
options.setOption(EXPRESSIONS_USE_PARENTHESES, CleanUpOptions.FALSE);
options.setOption(EXPRESSIONS_USE_PARENTHESES_NEVER, CleanUpOptions.TRUE);
options.setOption(EXPRESSIONS_USE_PARENTHESES_ALWAYS, CleanUpOptions.FALSE);
- options.setOption(CHECK_SIGN_OF_BITWISE_OPERATION, CleanUpOptions.FALSE);
options.setOption(EXTRACT_INCREMENT, CleanUpOptions.FALSE);
options.setOption(PULL_UP_ASSIGNMENT, CleanUpOptions.FALSE);
@@ -80,6 +79,7 @@
options.setOption(STATIC_INNER_CLASS, CleanUpOptions.FALSE);
options.setOption(STRINGBUILDER, CleanUpOptions.FALSE);
options.setOption(USE_LAZY_LOGICAL_OPERATOR, CleanUpOptions.FALSE);
+ options.setOption(PRIMITIVE_COMPARISON, CleanUpOptions.FALSE);
options.setOption(PRIMITIVE_PARSING, CleanUpOptions.FALSE);
options.setOption(PRIMITIVE_SERIALIZATION, CleanUpOptions.FALSE);
@@ -96,12 +96,14 @@
options.setOption(REMOVE_UNNECESSARY_CASTS, CleanUpOptions.TRUE);
options.setOption(REMOVE_UNNECESSARY_NLS_TAGS, CleanUpOptions.TRUE);
options.setOption(INSERT_INFERRED_TYPE_ARGUMENTS, CleanUpOptions.FALSE);
+ options.setOption(SUBSTRING, CleanUpOptions.FALSE);
options.setOption(ARRAYS_FILL, CleanUpOptions.FALSE);
options.setOption(EVALUATE_NULLABLE, CleanUpOptions.FALSE);
options.setOption(PUSH_DOWN_NEGATION, CleanUpOptions.FALSE);
options.setOption(DOUBLE_NEGATION, CleanUpOptions.FALSE);
options.setOption(REMOVE_REDUNDANT_COMPARISON_STATEMENT, CleanUpOptions.FALSE);
options.setOption(REDUNDANT_SUPER_CALL, CleanUpOptions.FALSE);
+ options.setOption(UNREACHABLE_BLOCK, CleanUpOptions.FALSE);
options.setOption(REDUNDANT_FALLING_THROUGH_BLOCK_END, CleanUpOptions.FALSE);
options.setOption(REDUNDANT_IF_CONDITION, CleanUpOptions.FALSE);
options.setOption(USE_DIRECTLY_MAP_METHOD, CleanUpOptions.FALSE);
@@ -148,15 +150,16 @@
options.setOption(MODERNIZE_HASH, CleanUpOptions.FALSE);
options.setOption(USE_OBJECTS_EQUALS, CleanUpOptions.FALSE);
+ // Code fixing
+ options.setOption(STANDARD_COMPARISON, CleanUpOptions.FALSE);
+ options.setOption(CHECK_SIGN_OF_BITWISE_OPERATION, CleanUpOptions.FALSE);
+
// Duplicate Code
options.setOption(TERNARY_OPERATOR, CleanUpOptions.FALSE);
options.setOption(STRICTLY_EQUAL_OR_DIFFERENT, CleanUpOptions.FALSE);
options.setOption(MERGE_CONDITIONAL_BLOCKS, CleanUpOptions.FALSE);
options.setOption(CONTROLFLOW_MERGE, CleanUpOptions.FALSE);
- // Code fixing
- options.setOption(STANDARD_COMPARISON, CleanUpOptions.FALSE);
-
// Java Features
options.setOption(USE_PATTERN_MATCHING_FOR_INSTANCEOF, CleanUpOptions.FALSE);
options.setOption(CONTROL_STATEMENTS_CONVERT_TO_SWITCH_EXPRESSIONS, CleanUpOptions.FALSE);
@@ -205,7 +208,6 @@
options.setOption(EXPRESSIONS_USE_PARENTHESES, CleanUpOptions.FALSE);
options.setOption(EXPRESSIONS_USE_PARENTHESES_NEVER, CleanUpOptions.TRUE);
options.setOption(EXPRESSIONS_USE_PARENTHESES_ALWAYS, CleanUpOptions.FALSE);
- options.setOption(CHECK_SIGN_OF_BITWISE_OPERATION, CleanUpOptions.FALSE);
options.setOption(EXTRACT_INCREMENT, CleanUpOptions.FALSE);
options.setOption(PULL_UP_ASSIGNMENT, CleanUpOptions.FALSE);
@@ -232,6 +234,7 @@
options.setOption(STATIC_INNER_CLASS, CleanUpOptions.FALSE);
options.setOption(STRINGBUILDER, CleanUpOptions.FALSE);
options.setOption(USE_LAZY_LOGICAL_OPERATOR, CleanUpOptions.FALSE);
+ options.setOption(PRIMITIVE_COMPARISON, CleanUpOptions.FALSE);
options.setOption(PRIMITIVE_PARSING, CleanUpOptions.FALSE);
options.setOption(PRIMITIVE_SERIALIZATION, CleanUpOptions.FALSE);
@@ -248,12 +251,14 @@
options.setOption(REMOVE_UNNECESSARY_CASTS, CleanUpOptions.TRUE);
options.setOption(REMOVE_UNNECESSARY_NLS_TAGS, CleanUpOptions.FALSE);
options.setOption(INSERT_INFERRED_TYPE_ARGUMENTS, CleanUpOptions.FALSE);
+ options.setOption(SUBSTRING, CleanUpOptions.FALSE);
options.setOption(ARRAYS_FILL, CleanUpOptions.FALSE);
options.setOption(EVALUATE_NULLABLE, CleanUpOptions.FALSE);
options.setOption(PUSH_DOWN_NEGATION, CleanUpOptions.FALSE);
options.setOption(DOUBLE_NEGATION, CleanUpOptions.FALSE);
options.setOption(REMOVE_REDUNDANT_COMPARISON_STATEMENT, CleanUpOptions.FALSE);
options.setOption(REDUNDANT_SUPER_CALL, CleanUpOptions.FALSE);
+ options.setOption(UNREACHABLE_BLOCK, CleanUpOptions.FALSE);
options.setOption(REDUNDANT_FALLING_THROUGH_BLOCK_END, CleanUpOptions.FALSE);
options.setOption(REDUNDANT_IF_CONDITION, CleanUpOptions.FALSE);
options.setOption(USE_DIRECTLY_MAP_METHOD, CleanUpOptions.FALSE);
@@ -268,9 +273,6 @@
options.setOption(REMOVE_USELESS_CONTINUE, CleanUpOptions.FALSE);
options.setOption(UNLOOPED_WHILE, CleanUpOptions.FALSE);
- // Code fixing
- options.setOption(STANDARD_COMPARISON, CleanUpOptions.FALSE);
-
//Missing Code
options.setOption(ADD_MISSING_ANNOTATIONS, CleanUpOptions.TRUE);
options.setOption(ADD_MISSING_ANNOTATIONS_OVERRIDE, CleanUpOptions.TRUE);
@@ -305,6 +307,10 @@
options.setOption(CLEANUP_ON_SAVE_ADDITIONAL_OPTIONS, CleanUpOptions.FALSE);
+ // Code fixing
+ options.setOption(STANDARD_COMPARISON, CleanUpOptions.FALSE);
+ options.setOption(CHECK_SIGN_OF_BITWISE_OPERATION, CleanUpOptions.FALSE);
+
// Duplicate Code
options.setOption(TERNARY_OPERATOR, CleanUpOptions.FALSE);
options.setOption(STRICTLY_EQUAL_OR_DIFFERENT, CleanUpOptions.FALSE);
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpRegistry.java b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpRegistry.java
index dcd7d3e..66829f9 100644
--- a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpRegistry.java
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpRegistry.java
@@ -434,7 +434,7 @@
Arrays.sort(fPageDescriptors, (o1, o2) -> {
String name1= o1.getName();
String name2= o2.getName();
- return Collator.getInstance().compare(name1.replaceAll("&", ""), name2.replaceAll("&", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ return Collator.getInstance().compare(name1.replace("&", ""), name2.replace("&", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
});
}
diff --git a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureProcessor.java b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureProcessor.java
index 57669bc..46a38a3 100644
--- a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureProcessor.java
+++ b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureProcessor.java
@@ -1275,7 +1275,7 @@
if (info.isDeleted())
buffer.append("{deleted}"); //$NON-NLS-1$
else
- buffer.append(info.getNewTypeName().replaceAll(" ", "")); //$NON-NLS-1$//$NON-NLS-2$
+ buffer.append(info.getNewTypeName().replace(" ", "")); //$NON-NLS-1$//$NON-NLS-2$
buffer.append(" "); //$NON-NLS-1$
if (info.isDeleted())
buffer.append("{deleted}"); //$NON-NLS-1$
diff --git a/org.eclipse.jdt.ui/plugin.properties b/org.eclipse.jdt.ui/plugin.properties
index e33b7c2..b684b6a 100644
--- a/org.eclipse.jdt.ui/plugin.properties
+++ b/org.eclipse.jdt.ui/plugin.properties
@@ -1214,6 +1214,7 @@
#--- Clean Up ---
CleanUpTabPage.CodeStyle.name = &Code Style
CleanUpTabPage.JavaFeature.name = &Java Feature
+CleanUpTabPage.SourceFixing.name = Source &Fixing
CleanUpTabPage.Optimization.name = O&ptimization
CleanUpTabPage.MemberAccesses.name = Membe&r Accesses
CleanUpTabPage.UnnecessaryCode.name = &Unnecessary Code
diff --git a/org.eclipse.jdt.ui/plugin.xml b/org.eclipse.jdt.ui/plugin.xml
index e1a26c1..cc1e418 100644
--- a/org.eclipse.jdt.ui/plugin.xml
+++ b/org.eclipse.jdt.ui/plugin.xml
@@ -7009,6 +7009,11 @@
cleanUpKind="cleanUp">
</cleanUpConfigurationUI>
<cleanUpConfigurationUI
+ class="org.eclipse.jdt.internal.ui.preferences.cleanup.SourceFixingTabPage"
+ name="%CleanUpTabPage.SourceFixing.name"
+ cleanUpKind="cleanUp">
+ </cleanUpConfigurationUI>
+ <cleanUpConfigurationUI
class="org.eclipse.jdt.internal.ui.preferences.cleanup.OptimizationTabPage"
name="%CleanUpTabPage.Optimization.name"
cleanUpKind="saveAction">
@@ -7098,14 +7103,9 @@
runAfter="org.eclipse.jdt.ui.cleanup.expressions">
</cleanUp>
<cleanUp
- class="org.eclipse.jdt.internal.ui.fix.BitwiseConditionalExpressionCleanup"
- id="org.eclipse.jdt.ui.cleanup.bitwise_conditional_expression"
- runAfter="org.eclipse.jdt.ui.cleanup.lambda_and_method_ref">
- </cleanUp>
- <cleanUp
class="org.eclipse.jdt.internal.ui.fix.ExtractIncrementCleanUp"
id="org.eclipse.jdt.ui.cleanup.extract_increment"
- runAfter="org.eclipse.jdt.ui.cleanup.bitwise_conditional_expression">
+ runAfter="org.eclipse.jdt.ui.cleanup.lambda_and_method_ref">
</cleanUp>
<cleanUp
class="org.eclipse.jdt.internal.ui.fix.PullUpAssignmentCleanUp"
@@ -7143,9 +7143,14 @@
runAfter="org.eclipse.jdt.ui.cleanup.stringbuilder">
</cleanUp>
<cleanUp
+ class="org.eclipse.jdt.internal.ui.fix.PrimitiveComparisonCleanUp"
+ id="org.eclipse.jdt.ui.cleanup.primitive_comparison"
+ runAfter="org.eclipse.jdt.ui.cleanup.lazy_logical">
+ </cleanUp>
+ <cleanUp
class="org.eclipse.jdt.internal.ui.fix.PrimitiveParsingCleanUp"
id="org.eclipse.jdt.ui.cleanup.primitive_parsing"
- runAfter="org.eclipse.jdt.ui.cleanup.lazy_logical">
+ runAfter="org.eclipse.jdt.ui.cleanup.primitive_comparison">
</cleanUp>
<cleanUp
class="org.eclipse.jdt.internal.ui.fix.PrimitiveSerializationCleanUp"
@@ -7248,9 +7253,14 @@
runAfter="org.eclipse.jdt.ui.cleanup.imports">
</cleanUp>
<cleanUp
+ class="org.eclipse.jdt.internal.ui.fix.SubstringCleanUp"
+ id="org.eclipse.jdt.ui.cleanup.substring"
+ runAfter="org.eclipse.jdt.ui.cleanup.format">
+ </cleanUp>
+ <cleanUp
class="org.eclipse.jdt.internal.ui.fix.ArraysFillCleanUp"
id="org.eclipse.jdt.ui.cleanup.arrays_fill"
- runAfter="org.eclipse.jdt.ui.cleanup.format">
+ runAfter="org.eclipse.jdt.ui.cleanup.substring">
</cleanUp>
<cleanUp
class="org.eclipse.jdt.internal.ui.fix.EvaluateNullableCleanUp"
@@ -7283,9 +7293,14 @@
runAfter="org.eclipse.jdt.ui.cleanup.comparison_statement">
</cleanUp>
<cleanUp
+ class="org.eclipse.jdt.internal.ui.fix.UnreachableBlockCleanUp"
+ id="org.eclipse.jdt.ui.cleanup.unreachable_block"
+ runAfter="org.eclipse.jdt.ui.cleanup.no_super">
+ </cleanUp>
+ <cleanUp
class="org.eclipse.jdt.internal.ui.fix.MapMethodCleanUp"
id="org.eclipse.jdt.ui.cleanup.use_directly_map_method"
- runAfter="org.eclipse.jdt.ui.cleanup.no_super">
+ runAfter="org.eclipse.jdt.ui.cleanup.unreachable_block">
</cleanUp>
<cleanUp
class="org.eclipse.jdt.internal.ui.fix.CollectionCloningCleanUp"
@@ -7303,9 +7318,14 @@
runAfter="org.eclipse.jdt.ui.cleanup.map_cloning">
</cleanUp>
<cleanUp
+ class="org.eclipse.jdt.internal.ui.fix.BitwiseConditionalExpressionCleanup"
+ id="org.eclipse.jdt.ui.cleanup.bitwise_conditional_expression"
+ runAfter="org.eclipse.jdt.ui.cleanup.standard_comparison">
+ </cleanUp>
+ <cleanUp
class="org.eclipse.jdt.internal.ui.fix.TernaryOperatorCleanUp"
id="org.eclipse.jdt.ui.cleanup.ternary_operator"
- runAfter="org.eclipse.jdt.ui.cleanup.standard_comparison">
+ runAfter="org.eclipse.jdt.ui.cleanup.bitwise_conditional_expression">
</cleanUp>
<cleanUp
class="org.eclipse.jdt.internal.ui.fix.StrictlyEqualOrDifferentCleanUp"
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.java
index bc5de30..07bad14 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.java
@@ -220,6 +220,7 @@
public static String GenerateConstructorUsingFieldsAction_tooltip;
public static String GenerateConstructorUsingFieldsAction_error_title;
public static String GenerateConstructorUsingFieldsAction_not_applicable;
+ public static String GenerateConstructorUsingFieldsAction_record_not_applicable;
public static String GenerateConstructorUsingFieldsAction_fields_selected;
public static String GenerateConstructorUsingFieldsAction_error_duplicate_constructor;
public static String GenerateConstructorUsingFieldsAction_error_nothing_found;
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.properties
index f0c2fc3..05fcac9 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/ActionMessages.properties
@@ -175,6 +175,7 @@
GenerateConstructorUsingFieldsAction_interface_not_applicable=The Generate Constructor using Fields operation is not applicable to interfaces.
GenerateConstructorUsingFieldsAction_enum_not_applicable=The Generate Constructor using Fields operation is not applicable to enums.
GenerateConstructorUsingFieldsAction_annotation_not_applicable=The Generate Constructor using Fields operation is not applicable to annotations.
+GenerateConstructorUsingFieldsAction_record_not_applicable=The Generate Constructor using Fields operation is not applicable to records.
GenerateConstructorUsingFieldsAction_typeContainsNoFields_message=The selected type contains no fields which may be initialized in a constructor.
GenerateConstructorUsingFieldsAction_error_actionfailed=Unexpected error while creating constructors. See log for details.
GenerateConstructorUsingFieldsAction_error_anonymous_class=Anonymous classes cannot contain explicitly declared constructors.
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/PrimitiveComparisonCleanUp.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/PrimitiveComparisonCleanUp.java
new file mode 100644
index 0000000..4cf1900
--- /dev/null
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/PrimitiveComparisonCleanUp.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Fabrice TIERCELIN and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Fabrice TIERCELIN - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.fix;
+
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.jdt.core.manipulation.ICleanUpFixCore;
+
+import org.eclipse.jdt.ui.cleanup.CleanUpContext;
+import org.eclipse.jdt.ui.cleanup.CleanUpOptions;
+import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
+import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
+
+/**
+ * A fix that replaces the <code>compareTo()</code> method by a comparison on primitive:
+ * <ul>
+ * <li>It improves the space and time performance,</li>
+ * <li>The compared value must be a primitive.</li>
+ * </ul>
+ */
+public class PrimitiveComparisonCleanUp extends AbstractCleanUp {
+ private PrimitiveComparisonCleanUpCore coreCleanUp= new PrimitiveComparisonCleanUpCore();
+
+ public PrimitiveComparisonCleanUp(final Map<String, String> options) {
+ setOptions(options);
+ }
+
+ public PrimitiveComparisonCleanUp() {
+ }
+
+ @Override
+ public void setOptions(final CleanUpOptions options) {
+ coreCleanUp.setOptions(options);
+ }
+
+ @Override
+ public CleanUpRequirements getRequirements() {
+ return new CleanUpRequirements(coreCleanUp.getRequirementsCore());
+ }
+
+ @Override
+ public ICleanUpFix createFix(final CleanUpContext context) throws CoreException {
+ ICleanUpFixCore fixCore= coreCleanUp.createFixCore(context);
+ return fixCore != null ? new CleanUpFixWrapper(fixCore) : null;
+ }
+
+ @Override
+ public String[] getStepDescriptions() {
+ return coreCleanUp.getStepDescriptions();
+ }
+
+ @Override
+ public String getPreview() {
+ return coreCleanUp.getPreview();
+ }
+}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/StaticInnerClassCleanUp.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/StaticInnerClassCleanUp.java
index e05c4ca..f5a0e35 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/StaticInnerClassCleanUp.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/StaticInnerClassCleanUp.java
@@ -145,7 +145,7 @@
&& binding.getKind() != IBinding.TYPE) {
ASTNode declaration= ((CompilationUnit) root).findDeclaringNode(binding);
- if (!ASTNodes.isParent(declaration, innerClass)) {
+ if (declaration == null || !ASTNodes.isParent(declaration, innerClass)) {
isTopLevelClassMemberUsed= true;
return interruptVisit();
}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/SubstringCleanUp.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/SubstringCleanUp.java
new file mode 100644
index 0000000..03c1baa
--- /dev/null
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/SubstringCleanUp.java
@@ -0,0 +1,145 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Fabrice TIERCELIN and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Fabrice TIERCELIN - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.fix;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.text.edits.TextEditGroup;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.MethodInvocation;
+import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+
+import org.eclipse.jdt.internal.corext.dom.ASTNodes;
+import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
+import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix;
+import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix.CompilationUnitRewriteOperation;
+import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
+import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
+
+import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
+import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
+import org.eclipse.jdt.ui.text.java.IProblemLocation;
+
+/**
+ * A fix that removes the second <code>substring()</code> parameter if this parameter is the length of the string:
+ * <ul>
+ * <li>It must reference the same expression,</li>
+ * <li>The expression must be passive.</li>
+ * </ul>
+ */
+public class SubstringCleanUp extends AbstractMultiFix {
+ public SubstringCleanUp() {
+ this(Collections.emptyMap());
+ }
+
+ public SubstringCleanUp(final Map<String, String> options) {
+ super(options);
+ }
+
+ @Override
+ public CleanUpRequirements getRequirements() {
+ boolean requireAST= isEnabled(CleanUpConstants.SUBSTRING);
+ return new CleanUpRequirements(requireAST, false, false, null);
+ }
+
+ @Override
+ public String[] getStepDescriptions() {
+ if (isEnabled(CleanUpConstants.SUBSTRING)) {
+ return new String[] { MultiFixMessages.SubstringCleanUp_description };
+ }
+
+ return new String[0];
+ }
+
+ @Override
+ public String getPreview() {
+ if (isEnabled(CleanUpConstants.SUBSTRING)) {
+ return "String shortenedText = text.substring(2);\n"; //$NON-NLS-1$
+ }
+
+ return "String shortenedText = text.substring(2, text.length());\n"; //$NON-NLS-1$
+ }
+
+ @Override
+ protected ICleanUpFix createFix(final CompilationUnit unit) throws CoreException {
+ if (!isEnabled(CleanUpConstants.SUBSTRING)) {
+ return null;
+ }
+
+ final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>();
+
+ unit.accept(new ASTVisitor() {
+ @Override
+ public boolean visit(final MethodInvocation visited) {
+ if (ASTNodes.usesGivenSignature(visited, String.class.getCanonicalName(), "substring", int.class.getCanonicalName(), int.class.getCanonicalName())) { //$NON-NLS-1$
+ MethodInvocation endIndex= ASTNodes.as((Expression) visited.arguments().get(1), MethodInvocation.class);
+
+ if (endIndex != null
+ && endIndex.getExpression() != null
+ && ASTNodes.usesGivenSignature(endIndex, String.class.getCanonicalName(), "length") //$NON-NLS-1$
+ && ASTNodes.match(visited.getExpression(), endIndex.getExpression())
+ && ASTNodes.isPassive(visited.getExpression())) {
+ rewriteOperations.add(new SubstringOperation(visited));
+ return false;
+ }
+ }
+
+ return true;
+ }
+ });
+
+ if (rewriteOperations.isEmpty()) {
+ return null;
+ }
+
+ return new CompilationUnitRewriteOperationsFix(MultiFixMessages.SubstringCleanUp_description, unit,
+ rewriteOperations.toArray(new CompilationUnitRewriteOperation[0]));
+ }
+
+ @Override
+ public boolean canFix(final ICompilationUnit compilationUnit, final IProblemLocation problem) {
+ return false;
+ }
+
+ @Override
+ protected ICleanUpFix createFix(final CompilationUnit unit, final IProblemLocation[] problems) throws CoreException {
+ return null;
+ }
+
+ private static class SubstringOperation extends CompilationUnitRewriteOperation {
+ private final MethodInvocation visited;
+
+ public SubstringOperation(final MethodInvocation visited) {
+ this.visited= visited;
+ }
+
+ @Override
+ public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException {
+ ASTRewrite rewrite= cuRewrite.getASTRewrite();
+ TextEditGroup group= createTextEditGroup(MultiFixMessages.SubstringCleanUp_description, cuRewrite);
+
+ rewrite.remove((ASTNode) visited.arguments().get(1), group);
+ }
+ }
+}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/UnreachableBlockCleanUp.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/UnreachableBlockCleanUp.java
new file mode 100644
index 0000000..dbb4e49
--- /dev/null
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/UnreachableBlockCleanUp.java
@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Fabrice TIERCELIN and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Fabrice TIERCELIN - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.fix;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.text.edits.TextEditGroup;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.IfStatement;
+import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+
+import org.eclipse.jdt.internal.corext.dom.ASTNodes;
+import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
+import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix;
+import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix.CompilationUnitRewriteOperation;
+import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
+import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
+
+import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
+import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
+import org.eclipse.jdt.ui.text.java.IProblemLocation;
+
+/**
+ * A fix that detects two <code>if</code> conditions that are identical and removes the second one:
+ * <ul>
+ * <li>The conditions should be passive,</li>
+ * <li>No exceptions should be awaited,</li>
+ * <li>It should not create unreachable code below the <code>if</code> statement which would create a compile error, that is to say the case where
+ * only the removed block doesn't fall through,
+ * all the other cases fall through,
+ * there is an <code>else</code> clause (not only <code>if</code>/<code>else</code> clauses)
+ * and a statement after the control workflow.</li>
+ * </ul>
+ */
+public class UnreachableBlockCleanUp extends AbstractMultiFix {
+ public UnreachableBlockCleanUp() {
+ this(Collections.emptyMap());
+ }
+
+ public UnreachableBlockCleanUp(final Map<String, String> options) {
+ super(options);
+ }
+
+ @Override
+ public CleanUpRequirements getRequirements() {
+ boolean requireAST= isEnabled(CleanUpConstants.UNREACHABLE_BLOCK);
+ return new CleanUpRequirements(requireAST, false, false, null);
+ }
+
+ @Override
+ public String[] getStepDescriptions() {
+ if (isEnabled(CleanUpConstants.UNREACHABLE_BLOCK)) {
+ return new String[] { MultiFixMessages.UnreachableBlockCleanUp_description };
+ }
+
+ return new String[0];
+ }
+
+ @Override
+ public String getPreview() {
+ StringBuilder bld= new StringBuilder();
+ bld.append("if (isValid && isFound) {\n"); //$NON-NLS-1$
+ bld.append(" return 0;\n"); //$NON-NLS-1$
+
+ if (!isEnabled(CleanUpConstants.UNREACHABLE_BLOCK)) {
+ bld.append("} else if (isFound && isValid) {\n"); //$NON-NLS-1$
+ bld.append(" return 1;\n"); //$NON-NLS-1$
+ }
+
+ bld.append("}\n"); //$NON-NLS-1$
+
+ if (isEnabled(CleanUpConstants.UNREACHABLE_BLOCK)) {
+ bld.append("\n\n"); //$NON-NLS-1$
+ }
+
+ return bld.toString();
+ }
+
+ @Override
+ protected ICleanUpFix createFix(final CompilationUnit unit) throws CoreException {
+ if (!isEnabled(CleanUpConstants.UNREACHABLE_BLOCK)) {
+ return null;
+ }
+
+ final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>();
+
+ unit.accept(new ASTVisitor() {
+ @Override
+ public boolean visit(final IfStatement visited) {
+ if (!ASTNodes.isExceptionExpected(visited)
+ && ASTNodes.isPassive(visited.getExpression())) {
+ boolean hasNoUnreachableCodeBelow= ASTNodes.getNextStatement(visited) == null
+ || !ASTNodes.fallsThrough(visited.getThenStatement());
+ IfStatement duplicateIf= visited;
+
+ do {
+ duplicateIf= ASTNodes.as(duplicateIf.getElseStatement(), IfStatement.class);
+
+ if (duplicateIf == null
+ || !ASTNodes.isPassive(duplicateIf.getExpression())) {
+ return true;
+ }
+
+ if ((hasNoUnreachableCodeBelow
+ || duplicateIf.getElseStatement() == null
+ || ASTNodes.fallsThrough(duplicateIf.getThenStatement())
+ || !ASTNodes.fallsThrough(duplicateIf.getElseStatement()))
+ && ASTNodes.isPassiveWithoutFallingThrough(duplicateIf.getExpression())
+ && ASTNodes.match(visited.getExpression(), duplicateIf.getExpression())) {
+ rewriteOperations.add(new UnreachableBlockOperation(duplicateIf));
+ return false;
+ }
+
+ hasNoUnreachableCodeBelow|= !ASTNodes.fallsThrough(duplicateIf.getThenStatement());
+ } while (true);
+ }
+
+ return true;
+ }
+ });
+
+ if (rewriteOperations.isEmpty()) {
+ return null;
+ }
+
+ return new CompilationUnitRewriteOperationsFix(MultiFixMessages.UnreachableBlockCleanUp_description, unit,
+ rewriteOperations.toArray(new CompilationUnitRewriteOperation[0]));
+ }
+
+ @Override
+ public boolean canFix(final ICompilationUnit compilationUnit, final IProblemLocation problem) {
+ return false;
+ }
+
+ @Override
+ protected ICleanUpFix createFix(final CompilationUnit unit, final IProblemLocation[] problems) throws CoreException {
+ return null;
+ }
+
+ private static class UnreachableBlockOperation extends CompilationUnitRewriteOperation {
+ private final IfStatement duplicateIf;
+
+ public UnreachableBlockOperation(final IfStatement duplicateIf) {
+ this.duplicateIf= duplicateIf;
+ }
+
+ @Override
+ public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException {
+ ASTRewrite rewrite= cuRewrite.getASTRewrite();
+ TextEditGroup group= createTextEditGroup(MultiFixMessages.UnreachableBlockCleanUp_description, cuRewrite);
+
+ if (duplicateIf.getElseStatement() == null) {
+ rewrite.remove(duplicateIf, group);
+ } else {
+ ASTNodes.replaceButKeepComment(rewrite, duplicateIf, ASTNodes.createMoveTarget(rewrite, duplicateIf.getElseStatement()), group);
+ }
+ }
+ }
+}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java
index f024959..c581eb8 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java
@@ -61,7 +61,6 @@
public static String CodeStyleTabPage_GroupName_ControlStatements;
public static String CodeStyleTabPage_GroupName_Expressions;
- public static String CodeStyleTabPage_CheckboxName_CheckSignOfBitwiseOperation;
public static String CodeStyleTabPage_CheckboxName_ExtractIncrement;
public static String CodeStyleTabPage_CheckboxName_PullUpAssignment;
public static String CodeStyleTabPage_CheckboxName_ElseIf;
@@ -87,6 +86,7 @@
public static String OptimizationTabPage_CheckboxName_StaticInnerClass;
public static String OptimizationTabPage_CheckboxName_StringBuilder;
public static String OptimizationTabPage_CheckboxName_UseLazyLogicalOperator;
+ public static String OptimizationTabPage_CheckboxName_PrimitiveComparison;
public static String OptimizationTabPage_CheckboxName_PrimitiveParsing;
public static String OptimizationTabPage_CheckboxName_PrimitiveSerialization;
public static String OptimizationTabPage_CheckboxName_PrecompileRegEx;
@@ -126,12 +126,14 @@
public static String UnnecessaryCodeTabPage_CheckboxName_UnnecessaryCasts;
public static String UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags;
+ public static String UnnecessaryCodeTabPage_CheckboxName_Substring;
public static String UnnecessaryCodeTabPage_CheckboxName_ArraysFill;
public static String UnnecessaryCodeTabPage_CheckboxName_EvaluateNullable;
public static String UnnecessaryCodeTabPage_CheckboxName_PushDownNegation;
public static String UnnecessaryCodeTabPage_CheckboxName_DoubleNegation;
public static String UnnecessaryCodeTabPage_CheckboxName_ComparisonStatement;
public static String UnnecessaryCodeTabPage_CheckboxName_RedundantSuperCall;
+ public static String UnnecessaryCodeTabPage_CheckboxName_UnreachableBlock;
public static String UnnecessaryCodeTabPage_CheckboxName_UseDirectlyMapMethod;
public static String UnnecessaryCodeTabPage_CheckboxName_CollectionCloning;
public static String UnnecessaryCodeTabPage_CheckboxName_MapCloning;
@@ -156,7 +158,12 @@
public static String UnnecessaryCodeTabPage_GroupName_UnnecessaryCode;
public static String UnnecessaryCodeTabPage_GroupName_UnusedCode;
- public static String CodeFixingTabPage_CheckboxName_StandardComparison;
+ public static String SourceFixingTabPage_warning;
+
+ public static String SourceFixingTabPage_GroupName_standardCode;
+
+ public static String SourceFixingTabPage_CheckboxName_StandardComparison;
+ public static String SourceFixingTabPage_CheckboxName_CheckSignOfBitwiseOperation;
public static String DuplicateCodeTabPage_GroupName_DuplicateCode;
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
index cbce94c..46b5119 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
@@ -41,7 +41,6 @@
CodeStyleTabPage_CheckboxName_ElseIf=C&ombine nested 'if' statement in 'else' block to 'else if'
CodeStyleTabPage_CheckboxName_ReduceIndentation=Reduce indentation when possible
CodeStyleTabPage_GroupName_Expressions=Expressions
-CodeStyleTabPage_CheckboxName_CheckSignOfBitwiseOperation=&Compare with != 0 for bitwise expressions (use it carefully, it may alter the behavior)
CodeStyleTabPage_CheckboxName_ExtractIncrement=Extract increment/decrement from statement
CodeStyleTabPage_CheckboxName_PullUpAssignment=Pull up assignment
CodeStyleTabPage_GroupName_NumberLiteral=Number literals
@@ -66,6 +65,7 @@
OptimizationTabPage_CheckboxName_StaticInnerClass=Make inner classes static where possible
OptimizationTabPage_CheckboxName_StringBuilder=Replace &String concatenation by StringBuilder
OptimizationTabPage_CheckboxName_UseLazyLogicalOperator=Use la&zy logical operator
+OptimizationTabPage_CheckboxName_PrimitiveComparison=Primitive comparison
OptimizationTabPage_CheckboxName_PrimitiveParsing=Primitive parsing
OptimizationTabPage_CheckboxName_PrimitiveSerialization=&Primitive serialization
OptimizationTabPage_CheckboxName_PrecompileRegEx=Precompile reused regular e&xpressions
@@ -112,12 +112,14 @@
UnnecessaryCodeTabPage_GroupName_UnnecessaryCode=Unnecessary code
UnnecessaryCodeTabPage_CheckboxName_UnnecessaryCasts=Remove unnecessar&y casts
UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags=Remove unnecessary '$NON-NLS$' ta&gs
+UnnecessaryCodeTabPage_CheckboxName_Substring=Redundant String.substring() parameter
UnnecessaryCodeTabPage_CheckboxName_ArraysFill=Use Arrays.&fill() when possible
UnnecessaryCodeTabPage_CheckboxName_EvaluateNullable=Evaluate without null check
UnnecessaryCodeTabPage_CheckboxName_PushDownNegation=Push d&own negation
UnnecessaryCodeTabPage_CheckboxName_DoubleNegation=Double negation
UnnecessaryCodeTabPage_CheckboxName_ComparisonStatement=Remove redundant comparison statement
UnnecessaryCodeTabPage_CheckboxName_RedundantSuperCall=Remove redundant s&uper() call in constructor
+UnnecessaryCodeTabPage_CheckboxName_UnreachableBlock=Unreachable block
UnnecessaryCodeTabPage_CheckboxName_UseDirectlyMapMethod=Operate on &Maps directly
UnnecessaryCodeTabPage_CheckboxName_CollectionCloning=Initialize collection at creation
UnnecessaryCodeTabPage_CheckboxName_MapCloning=Initiali&ze map at creation
@@ -133,7 +135,12 @@
UnnecessaryCodeTabPage_CheckboxName_UselessContinue=&Remove useless continue
UnnecessaryCodeTabPage_CheckboxName_UnloopedWhile=Convert loop into if when possible
-CodeFixingTabPage_CheckboxName_StandardComparison=Compare to zero
+SourceFixingTabPage_warning=These cleanups may change runtime behavior. Use them carefully.
+
+SourceFixingTabPage_GroupName_standardCode=Code standardization
+
+SourceFixingTabPage_CheckboxName_StandardComparison=Compare to zero
+SourceFixingTabPage_CheckboxName_CheckSignOfBitwiseOperation=&Compare with != 0 for bitwise expressions
DuplicateCodeTabPage_GroupName_DuplicateCode=Duplicate code
DuplicateCodeTabPage_CheckboxName_TernaryOperator=Replace (X &&&& Y) || (!X &&&& Z) by X ? Y : Z
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CodeStyleTabPage.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CodeStyleTabPage.java
index d0bdee9..651592a 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CodeStyleTabPage.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CodeStyleTabPage.java
@@ -22,7 +22,6 @@
import org.eclipse.jdt.internal.ui.fix.AbstractCleanUp;
import org.eclipse.jdt.internal.ui.fix.AddAllCleanUp;
-import org.eclipse.jdt.internal.ui.fix.BitwiseConditionalExpressionCleanup;
import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;
import org.eclipse.jdt.internal.ui.fix.ElseIfCleanUp;
import org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp;
@@ -31,7 +30,6 @@
import org.eclipse.jdt.internal.ui.fix.NumberSuffixCleanUp;
import org.eclipse.jdt.internal.ui.fix.PullUpAssignmentCleanUp;
import org.eclipse.jdt.internal.ui.fix.ReduceIndentationCleanUp;
-import org.eclipse.jdt.internal.ui.fix.StandardComparisonCleanUp;
import org.eclipse.jdt.internal.ui.fix.SwitchCleanUp;
import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;
@@ -47,8 +45,6 @@
new ElseIfCleanUp(values),
new ReduceIndentationCleanUp(values),
new ExpressionsCleanUp(values),
- new BitwiseConditionalExpressionCleanup(values),
- new StandardComparisonCleanUp(values),
new ExtractIncrementCleanUp(values),
new PullUpAssignmentCleanUp(values),
new NumberSuffixCleanUp(values),
@@ -91,12 +87,6 @@
final RadioPreference useParenthesesNeverPref= createRadioPref(expressionsGroup, 1, CleanUpMessages.CodeStyleTabPage_RadioName_NeverUseParantheses, CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER, CleanUpModifyDialog.FALSE_TRUE);
registerSlavePreference(useParenthesesPref, new RadioPreference[] {useParenthesesAlwaysPref, useParenthesesNeverPref});
- final CheckboxPreference bitwiseComparison= createCheckboxPref(expressionsGroup, numColumns, CleanUpMessages.CodeStyleTabPage_CheckboxName_CheckSignOfBitwiseOperation, CleanUpConstants.CHECK_SIGN_OF_BITWISE_OPERATION, CleanUpModifyDialog.FALSE_TRUE);
- registerPreference(bitwiseComparison);
-
- final CheckboxPreference standardComparisonPref= createCheckboxPref(expressionsGroup, numColumns, CleanUpMessages.CodeFixingTabPage_CheckboxName_StandardComparison, CleanUpConstants.STANDARD_COMPARISON, CleanUpModifyDialog.FALSE_TRUE);
- registerPreference(standardComparisonPref);
-
final CheckboxPreference extractIncrementPref= createCheckboxPref(expressionsGroup, numColumns, CleanUpMessages.CodeStyleTabPage_CheckboxName_ExtractIncrement, CleanUpConstants.EXTRACT_INCREMENT, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(extractIncrementPref);
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/OptimizationTabPage.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/OptimizationTabPage.java
index a166f7a..ca79c45 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/OptimizationTabPage.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/OptimizationTabPage.java
@@ -26,10 +26,11 @@
import org.eclipse.jdt.internal.ui.fix.LazyLogicalCleanUp;
import org.eclipse.jdt.internal.ui.fix.NoStringCreationCleanUp;
import org.eclipse.jdt.internal.ui.fix.PatternCleanUp;
+import org.eclipse.jdt.internal.ui.fix.PrimitiveComparisonCleanUp;
import org.eclipse.jdt.internal.ui.fix.PrimitiveParsingCleanUp;
import org.eclipse.jdt.internal.ui.fix.PrimitiveSerializationCleanUp;
-import org.eclipse.jdt.internal.ui.fix.StaticInnerClassCleanUp;
import org.eclipse.jdt.internal.ui.fix.SingleUsedFieldCleanUp;
+import org.eclipse.jdt.internal.ui.fix.StaticInnerClassCleanUp;
import org.eclipse.jdt.internal.ui.fix.StringBuilderCleanUp;
public final class OptimizationTabPage extends AbstractCleanUpTabPage {
@@ -43,6 +44,7 @@
new StaticInnerClassCleanUp(values),
new StringBuilderCleanUp(values),
new LazyLogicalCleanUp(values),
+ new PrimitiveComparisonCleanUp(values),
new PrimitiveParsingCleanUp(values),
new PrimitiveSerializationCleanUp(values),
new PatternCleanUp(values),
@@ -71,6 +73,9 @@
CleanUpConstants.USE_LAZY_LOGICAL_OPERATOR, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(useLazyLogicalPref);
+ final CheckboxPreference primitiveComparisonPref= createCheckboxPref(optimizationGroup, numColumns, CleanUpMessages.OptimizationTabPage_CheckboxName_PrimitiveComparison, CleanUpConstants.PRIMITIVE_COMPARISON, CleanUpModifyDialog.FALSE_TRUE);
+ registerPreference(primitiveComparisonPref);
+
final CheckboxPreference primitiveParsingPref= createCheckboxPref(optimizationGroup, numColumns, CleanUpMessages.OptimizationTabPage_CheckboxName_PrimitiveParsing, CleanUpConstants.PRIMITIVE_PARSING, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(primitiveParsingPref);
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/SourceFixingTabPage.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/SourceFixingTabPage.java
new file mode 100644
index 0000000..096e5ef
--- /dev/null
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/SourceFixingTabPage.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2021 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Fabrice TIERCELIN - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.preferences.cleanup;
+
+import java.util.Map;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+
+import org.eclipse.jface.dialogs.Dialog;
+
+import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
+
+import org.eclipse.jdt.internal.ui.fix.AbstractCleanUp;
+import org.eclipse.jdt.internal.ui.fix.BitwiseConditionalExpressionCleanup;
+import org.eclipse.jdt.internal.ui.fix.StandardComparisonCleanUp;
+
+public final class SourceFixingTabPage extends AbstractCleanUpTabPage {
+ public static final String ID= "org.eclipse.jdt.ui.cleanup.tabpage.source_fixing"; //$NON-NLS-1$
+
+ @Override
+ protected AbstractCleanUp[] createPreviewCleanUps(final Map<String, String> values) {
+ return new AbstractCleanUp[] {
+ new StandardComparisonCleanUp(values),
+ new BitwiseConditionalExpressionCleanup(values)
+ };
+ }
+
+ @Override
+ protected void doCreatePreferences(final Composite composite, final int numColumns) {
+ final Label warningImage= new Label(composite, SWT.LEFT | SWT.WRAP);
+ warningImage.setImage(Dialog.getImage(Dialog.DLG_IMG_MESSAGE_WARNING));
+ warningImage.setLayoutData(new GridData(GridData.BEGINNING, GridData.CENTER, false, false));
+ createLabel(numColumns - 1, composite, CleanUpMessages.SourceFixingTabPage_warning);
+
+ Group standardCodeGroup= createGroup(numColumns, composite, CleanUpMessages.SourceFixingTabPage_GroupName_standardCode);
+
+ final CheckboxPreference standardComparisonPref= createCheckboxPref(standardCodeGroup, numColumns, CleanUpMessages.SourceFixingTabPage_CheckboxName_StandardComparison, CleanUpConstants.STANDARD_COMPARISON, CleanUpModifyDialog.FALSE_TRUE);
+ registerPreference(standardComparisonPref);
+
+ final CheckboxPreference bitwiseComparisonPref= createCheckboxPref(standardCodeGroup, numColumns, CleanUpMessages.SourceFixingTabPage_CheckboxName_CheckSignOfBitwiseOperation, CleanUpConstants.CHECK_SIGN_OF_BITWISE_OPERATION, CleanUpModifyDialog.FALSE_TRUE);
+ registerPreference(bitwiseComparisonPref);
+ }
+}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java
index ddce1ca..2219d66 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java
@@ -36,9 +36,11 @@
import org.eclipse.jdt.internal.ui.fix.RedundantSemicolonsCleanUp;
import org.eclipse.jdt.internal.ui.fix.RedundantSuperCallCleanUp;
import org.eclipse.jdt.internal.ui.fix.StringCleanUp;
+import org.eclipse.jdt.internal.ui.fix.SubstringCleanUp;
import org.eclipse.jdt.internal.ui.fix.UnloopedWhileCleanUp;
import org.eclipse.jdt.internal.ui.fix.UnnecessaryArrayCreationCleanUp;
import org.eclipse.jdt.internal.ui.fix.UnnecessaryCodeCleanUp;
+import org.eclipse.jdt.internal.ui.fix.UnreachableBlockCleanUp;
import org.eclipse.jdt.internal.ui.fix.UnusedCodeCleanUp;
import org.eclipse.jdt.internal.ui.fix.UselessContinueCleanUp;
import org.eclipse.jdt.internal.ui.fix.UselessReturnCleanUp;
@@ -51,6 +53,7 @@
return new AbstractCleanUp[] {
new UnusedCodeCleanUp(values),
new UnnecessaryCodeCleanUp(values),
+ new SubstringCleanUp(values),
new StringCleanUp(values),
new ArraysFillCleanUp(values),
new EvaluateNullableCleanUp(values),
@@ -58,6 +61,7 @@
new DoubleNegationCleanUp(values),
new RedundantComparisonStatementCleanUp(values),
new RedundantSuperCallCleanUp(values),
+ new UnreachableBlockCleanUp(values),
new MapMethodCleanUp(values),
new CollectionCloningCleanUp(values),
new MapCloningCleanUp(values),
@@ -98,6 +102,9 @@
CheckboxPreference nls= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags, CleanUpConstants.REMOVE_UNNECESSARY_NLS_TAGS, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(nls);
+ CheckboxPreference substring= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_Substring, CleanUpConstants.SUBSTRING, CleanUpModifyDialog.FALSE_TRUE);
+ registerPreference(substring);
+
CheckboxPreference arraysFill= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_ArraysFill, CleanUpConstants.ARRAYS_FILL, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(arraysFill);
@@ -117,6 +124,9 @@
CheckboxPreference redundantSuperCall= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_RedundantSuperCall, CleanUpConstants.REDUNDANT_SUPER_CALL, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(redundantSuperCall);
+ CheckboxPreference unreachableBlock= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_UnreachableBlock, CleanUpConstants.UNREACHABLE_BLOCK, CleanUpModifyDialog.FALSE_TRUE);
+ registerPreference(unreachableBlock);
+
CheckboxPreference mapMethod= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_UseDirectlyMapMethod,
CleanUpConstants.USE_DIRECTLY_MAP_METHOD, CleanUpModifyDialog.FALSE_TRUE);
registerPreference(mapMethod);
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/ConvertStringConcatenationProposals.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/ConvertStringConcatenationProposals.java
index f5e1029..90cbed2 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/ConvertStringConcatenationProposals.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/ConvertStringConcatenationProposals.java
@@ -284,7 +284,7 @@
if (operand instanceof StringLiteral) {
String value= ((StringLiteral) operand).getEscapedValue();
value= value.substring(1, value.length() - 1);
- value= value.replaceAll("'", "''"); //$NON-NLS-1$ //$NON-NLS-2$
+ value= value.replace("'", "''"); //$NON-NLS-1$ //$NON-NLS-2$
formatString.append(value);
} else {
formatString.append("{").append(i).append("}"); //$NON-NLS-1$ //$NON-NLS-2$
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/MethodProposalInfo.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/MethodProposalInfo.java
index 2f4e00d..2ce106c 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/MethodProposalInfo.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/MethodProposalInfo.java
@@ -218,7 +218,7 @@
private String computeSimpleTypeName(String signature, Map<String, char[]> typeVariables) {
// method equality uses erased types
String erasure= Signature.getTypeErasure(signature);
- erasure= erasure.replaceAll("/", "."); //$NON-NLS-1$//$NON-NLS-2$
+ erasure= erasure.replace('/', '.');
String simpleName= Signature.getSimpleName(Signature.toString(erasure));
char[] typeVar= typeVariables.get(simpleName);
if (typeVar != null)
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java
index 195b162..92fa933 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java
@@ -758,7 +758,7 @@
return Strings.markJavaElementLabelLTR(buf.toString());
} else {
String label= JavaElementLabels.getElementLabel(element, flags);
- return label.replaceAll("<", "<").replaceAll(">", ">"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ return label.replace("<", "<").replace(">", ">"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
}
}
@@ -781,7 +781,7 @@
return Strings.markJavaElementLabelLTR(buf.toString());
} else {
String label= JavaElementLabels.getElementLabel(element, flags);
- return label.replaceAll("<", "<").replaceAll(">", ">"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ return label.replace("<", "<").replace(">", ">"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
}
}
}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/GenerateNewConstructorUsingFieldsAction.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/GenerateNewConstructorUsingFieldsAction.java
index 7c2b25b..c468938 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/GenerateNewConstructorUsingFieldsAction.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/GenerateNewConstructorUsingFieldsAction.java
@@ -134,7 +134,7 @@
if ((selection.size() == 1) && (selection.getFirstElement() instanceof IType)) {
IType type= (IType) selection.getFirstElement();
- return type.getCompilationUnit() != null && !type.isInterface() && !type.isAnnotation() && !type.isAnonymous();
+ return type.getCompilationUnit() != null && !type.isInterface() && !type.isAnnotation() && !type.isAnonymous() && !type.isRecord();
}
if ((selection.size() == 1) && (selection.getFirstElement() instanceof ICompilationUnit))
@@ -236,20 +236,27 @@
}
Object firstElement= selection.getFirstElement();
+ IType typeToProcess= null;
if (firstElement instanceof IType) {
- run((IType) firstElement, new IField[0], false);
+ typeToProcess= (IType)firstElement;
} else if (firstElement instanceof ICompilationUnit) {
- IType type= ((ICompilationUnit) firstElement).findPrimaryType();
- if (type.isAnnotation()) {
+ typeToProcess= ((ICompilationUnit) firstElement).findPrimaryType();
+ }
+ if (typeToProcess != null) {
+ if (typeToProcess.isAnnotation()) {
MessageDialog.openInformation(getShell(), ActionMessages.GenerateConstructorUsingFieldsAction_error_title, ActionMessages.GenerateConstructorUsingFieldsAction_annotation_not_applicable);
notifyResult(false);
return;
- } else if (type.isInterface()) {
+ } else if (typeToProcess.isInterface()) {
MessageDialog.openInformation(getShell(), ActionMessages.GenerateConstructorUsingFieldsAction_error_title, ActionMessages.GenerateConstructorUsingFieldsAction_interface_not_applicable);
notifyResult(false);
return;
+ } else if (typeToProcess.isRecord()) {
+ MessageDialog.openInformation(getShell(), ActionMessages.GenerateConstructorUsingFieldsAction_error_title, ActionMessages.GenerateConstructorUsingFieldsAction_record_not_applicable);
+ notifyResult(false);
+ return;
} else
- run(((ICompilationUnit) firstElement).findPrimaryType(), new IField[0], false);
+ run(typeToProcess, new IField[0], false);
}
} catch (CoreException exception) {
ExceptionHandler.handle(exception, getShell(), ActionMessages.GenerateConstructorUsingFieldsAction_error_title, ActionMessages.GenerateConstructorUsingFieldsAction_error_actionfailed);
@@ -273,7 +280,9 @@
if (element != null) {
IType type= (IType) element.getAncestor(IJavaElement.TYPE);
if (type != null) {
- if (type.getFields().length > 0) {
+ if (type.isRecord()) {
+ MessageDialog.openInformation(getShell(), ActionMessages.GenerateConstructorUsingFieldsAction_error_title, ActionMessages.GenerateConstructorUsingFieldsAction_record_not_applicable);
+ } else if (type.getFields().length > 0) {
run(type, new IField[0], true);
} else {
MessageDialog.openInformation(getShell(), ActionMessages.GenerateConstructorUsingFieldsAction_error_title, ActionMessages.GenerateConstructorUsingFieldsAction_typeContainsNoFields_message);
diff --git a/org.eclipse.ltk.core.refactoring/META-INF/MANIFEST.MF b/org.eclipse.ltk.core.refactoring/META-INF/MANIFEST.MF
index d053a45..7b7a642 100644
--- a/org.eclipse.ltk.core.refactoring/META-INF/MANIFEST.MF
+++ b/org.eclipse.ltk.core.refactoring/META-INF/MANIFEST.MF
@@ -21,7 +21,7 @@
org.eclipse.core.expressions;bundle-version="[3.4.100,4.0.0)",
org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)",
org.eclipse.core.filebuffers;bundle-version="[3.5.0,4.0.0)",
- org.eclipse.core.resources;bundle-version="[3.5.0,4.0.0)",
+ org.eclipse.core.resources;bundle-version="[3.14.0,4.0.0)",
org.eclipse.core.commands;bundle-version="[3.5.0,4.0.0)",
org.eclipse.text;bundle-version="[3.5.0,4.0.0)"
Bundle-RequiredExecutionEnvironment: JavaSE-1.8
diff --git a/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/internal/core/refactoring/resource/undostates/MarkerUndoState.java b/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/internal/core/refactoring/resource/undostates/MarkerUndoState.java
index b8d972f..83ed85a 100644
--- a/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/internal/core/refactoring/resource/undostates/MarkerUndoState.java
+++ b/org.eclipse.ltk.core.refactoring/src/org/eclipse/ltk/internal/core/refactoring/resource/undostates/MarkerUndoState.java
@@ -35,7 +35,7 @@
protected IResource resource;
private String type;
- private Map<String, ? extends Object> attributes;
+ private Map<String, Object> attributes;
/**
*
@@ -53,31 +53,13 @@
}
/**
- * Create a {@link MarkerUndoState} from the specified marker type, attributes,
- * and resource.
- *
- * @param type
- * the type of marker to be created.
- * @param attributes
- * the attributes to be assigned to the marker
- * @param resource
- * the resource on which the marker should be created
- */
- public MarkerUndoState(String type, Map<String, ? extends Object> attributes, IResource resource) {
- this.type = type;
- this.attributes = attributes;
- this.resource = resource;
- }
-
- /**
* Create a marker from the marker description.
*
* @return the created marker
* @throws CoreException if the marker could not be created
*/
public IMarker createMarker() throws CoreException {
- IMarker marker = resource.createMarker(type);
- marker.setAttributes(attributes);
+ IMarker marker = resource.createMarker(type, attributes);
return marker;
}
