Bug 479559: [extract method] Extract method with 'replace

additional occurrences' does not analyze additional occurrences

Change-Id: I13fcd4593c929d6792b84d279b94d97f08c4fd81

10 files changed, 269 insertions, 21 deletions

diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test990.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test990.java
new file mode 100644
index 0000000000..dcf95af41b
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test990.java
@@ -0,0 +1,18 @@
+package duplicates_in;
+
+public class A_test990 {
+	public static void main(String[] args) {
+		for (int i = 0; i < 1; i++) {
+			int idx = 0;
+			for (int j = 0; j < 3; j++) {
+				idx++;
+				System.out.println(idx);
+			}
+			// for-loop to extract:
+			/*[*/for (int j = 0; j < 3; j++) {
+				idx++;
+				System.out.println(idx);
+			}/*]*/
+		}
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test991.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test991.java
new file mode 100644
index 0000000000..3248c27052
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test991.java
@@ -0,0 +1,17 @@
+package duplicates_in;
+
+public class A_test991 {
+	public static void main(String[] args) {
+		for (int i = 0; i < 1; i++) {
+			int idx = 0;
+			/*[*/for (int j = 0; j < 3; j++) {
+				idx++;
+				System.out.println(idx);
+			}/*]*/
+			for (int j = 0; j < 3; j++) {
+				idx++;
+				System.out.println(idx);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test992.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test992.java
new file mode 100644
index 0000000000..d7c093d6c6
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_in/A_test992.java
@@ -0,0 +1,13 @@
+package duplicates_in;
+
+public class A_test992 {
+	void a() {
+		/*[*/int xxx= 0, yyy= 1;/*]*/
+		System.out.println(xxx);
+	}
+	
+	void b() {
+		int xxx= 0, yyy= 1;
+		System.out.println(yyy);
+	}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test990.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test990.java
new file mode 100644
index 0000000000..0e591f6fe0
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test990.java
@@ -0,0 +1,22 @@
+package duplicates_out;

+

+public class A_test990 {

+	public static void main(String[] args) {

+		for (int i = 0; i < 1; i++) {

+			int idx = 0;

+			for (int j = 0; j < 3; j++) {

+				idx++;

+				System.out.println(idx);

+			}

+			// for-loop to extract:

+			extracted(idx);

+		}

+	}

+

+	protected static void extracted(int idx) {

+		/*[*/for (int j = 0; j < 3; j++) {

+			idx++;

+			System.out.println(idx);

+		}/*]*/

+	}

+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test991.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test991.java
new file mode 100644
index 0000000000..5b9f49168b
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test991.java
@@ -0,0 +1,19 @@
+package duplicates_out;

+

+public class A_test991 {

+	public static void main(String[] args) {

+		for (int i = 0; i < 1; i++) {

+			int idx = 0;

+			idx = extracted(idx);

+			idx = extracted(idx);

+		}

+	}

+

+	protected static int extracted(int idx) {

+		/*[*/for (int j = 0; j < 3; j++) {

+			idx++;

+			System.out.println(idx);

+		}/*]*/

+		return idx;

+	}

+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test992.java b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test992.java
new file mode 100644
index 0000000000..bee4c95e0f
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractMethodWorkSpace/ExtractMethodTests/duplicates_out/A_test992.java
@@ -0,0 +1,18 @@
+package duplicates_out;

+

+public class A_test992 {

+	void a() {

+		int xxx = extracted();

+		System.out.println(xxx);

+	}

+

+	protected int extracted() {

+		/*[*/int xxx= 0, yyy= 1;/*]*/

+		return xxx;

+	}

+	

+	void b() {

+		int xxx= 0, yyy= 1;

+		System.out.println(yyy);

+	}

+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests.java b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests.java
index bd7632b06f..3ad38f7afb 100644
--- a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests.java
+++ b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractMethodTests.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2015 IBM Corporation and others.
+ * Copyright (c) 2000, 2017 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -1940,6 +1940,18 @@ public class ExtractMethodTests extends AbstractSelectionTestCase {
 		duplicatesTest();
 	}
 
+	public void test990() throws Exception {
+		duplicatesTest();
+	}
+
+	public void test991() throws Exception {
+		duplicatesTest();
+	}
+
+	public void test992() throws Exception {
+		duplicatesTest();
+	}
+
 	//---- Test code in initializers -----------------------------------------------
 
 	public void test1000() throws Exception {
diff --git a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodAnalyzer.java b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodAnalyzer.java
index 35731afa8b..79aaa6912d 100644
--- a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodAnalyzer.java
+++ b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodAnalyzer.java
@@ -56,6 +56,7 @@ import org.eclipse.jdt.core.dom.LambdaExpression;
 import org.eclipse.jdt.core.dom.Message;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.Name;
+import org.eclipse.jdt.core.dom.NodeFinder;
 import org.eclipse.jdt.core.dom.PrimitiveType;
 import org.eclipse.jdt.core.dom.QualifiedName;
 import org.eclipse.jdt.core.dom.SimpleName;
@@ -77,6 +78,8 @@ import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.TypeLocation;
 
+import org.eclipse.jdt.internal.core.manipulation.dom.ASTResolving;
+import org.eclipse.jdt.internal.core.manipulation.util.BasicElementLabels;
 import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
 import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
@@ -97,8 +100,6 @@ import org.eclipse.jdt.internal.corext.util.Messages;
 
 import org.eclipse.jdt.ui.JavaElementLabels;
 
-import org.eclipse.jdt.internal.core.manipulation.dom.ASTResolving;
-import org.eclipse.jdt.internal.core.manipulation.util.BasicElementLabels;
 import org.eclipse.jdt.internal.ui.viewsupport.BindingLabelProvider;
 
 /* package */ class ExtractMethodAnalyzer extends CodeAnalyzer {
@@ -794,7 +795,26 @@ import org.eclipse.jdt.internal.ui.viewsupport.BindingLabelProvider;
 					}
 					if (name.resolveBinding() instanceof IVariableBinding) {
 						StructuralPropertyDescriptor locationInParent= name.getLocationInParent();
-						if (locationInParent == QualifiedName.NAME_PROPERTY || (locationInParent == FieldAccess.NAME_PROPERTY && !(((FieldAccess) name.getParent()).getExpression() instanceof ThisExpression)))  {
+						boolean isPartOfQualifiedName= false;
+						boolean isPartOfQualifier= false;
+						if (locationInParent == QualifiedName.NAME_PROPERTY) {
+							isPartOfQualifiedName= true;
+							QualifiedName qualifiedName= (QualifiedName) name.getParent();
+							QualifiedName currParent= qualifiedName;
+							while (true) {
+								ASTNode parent= currParent.getParent();
+								if (parent instanceof QualifiedName) {
+									currParent= (QualifiedName) parent;
+								} else {
+									break;
+								}
+							}
+							if (!qualifiedName.equals(currParent)) {
+								isPartOfQualifier= true;
+							}
+						}
+						if ((isPartOfQualifiedName && !isPartOfQualifier)
+								|| (locationInParent == FieldAccess.NAME_PROPERTY && !(((FieldAccess) name.getParent()).getExpression() instanceof ThisExpression))) {
 							status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_part_of_qualified_name);
 							break superCall;
 						}
@@ -827,7 +847,9 @@ import org.eclipse.jdt.internal.ui.viewsupport.BindingLabelProvider;
 	@Override
 	public boolean visit(Assignment node) {
 		boolean result= super.visit(node);
-		if ((getSelection().covers(node.getLeftHandSide()) && !getSelection().covers(node.getRightHandSide())) || getSelection().coveredBy(node.getLeftHandSide())) {
+		Selection selection= getSelection();
+		ASTNode selectedNode= NodeFinder.perform(node, selection.getOffset(), selection.getLength());
+		if ((selectedNode != null && SnippetFinder.isLeftHandSideOfAssignment(selectedNode)) || (selection.covers(node.getLeftHandSide()) && !selection.covers(node.getRightHandSide()))) {
 			invalidSelection(
 				RefactoringCoreMessages.ExtractMethodAnalyzer_leftHandSideOfAssignment,
 				JavaStatusContext.create(fCUnit, node));
diff --git a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodRefactoring.java b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodRefactoring.java
index 0ffd8b2ebb..1be1ae7d92 100644
--- a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodRefactoring.java
+++ b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodRefactoring.java
@@ -83,6 +83,7 @@ import org.eclipse.jdt.core.dom.ReturnStatement;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
 import org.eclipse.jdt.core.dom.Statement;
+import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
 import org.eclipse.jdt.core.dom.ThisExpression;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
@@ -101,6 +102,8 @@ import org.eclipse.jdt.core.refactoring.IJavaRefactorings;
 import org.eclipse.jdt.core.refactoring.descriptors.ExtractMethodDescriptor;
 import org.eclipse.jdt.core.refactoring.descriptors.JavaRefactoringDescriptor;
 
+import org.eclipse.jdt.internal.core.manipulation.dom.ASTResolving;
+import org.eclipse.jdt.internal.core.manipulation.util.BasicElementLabels;
 import org.eclipse.jdt.internal.core.refactoring.descriptors.RefactoringSignatureDescriptorFactory;
 import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
 import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
@@ -119,6 +122,7 @@ import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringArguments;
 import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringDescriptorUtil;
 import org.eclipse.jdt.internal.corext.refactoring.ParameterInfo;
 import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
+import org.eclipse.jdt.internal.corext.refactoring.code.SnippetFinder.Match;
 import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;
 import org.eclipse.jdt.internal.corext.refactoring.util.ResourceUtil;
 import org.eclipse.jdt.internal.corext.refactoring.util.SelectionAwareSourceRangeComputer;
@@ -129,9 +133,6 @@ import org.eclipse.jdt.ui.CodeGeneration;
 import org.eclipse.jdt.ui.JavaElementLabels;
 
 import org.eclipse.jdt.internal.ui.text.correction.ModifierCorrectionSubProcessor;
-
-import org.eclipse.jdt.internal.core.manipulation.dom.ASTResolving;
-import org.eclipse.jdt.internal.core.manipulation.util.BasicElementLabels;
 import org.eclipse.jdt.internal.ui.viewsupport.BindingLabelProvider;
 
 /**
@@ -160,7 +161,7 @@ public class ExtractMethodRefactoring extends Refactoring {
 	private Set<String> fUsedNames;
 	private boolean fGenerateJavadoc;
 	private boolean fReplaceDuplicates;
-	private SnippetFinder.Match[] fDuplicates;
+	private List<SnippetFinder.Match> fDuplicates;
 	private int fDestinationIndex= 0;
 	// either of type TypeDeclaration or AnonymousClassDeclaration
 	private ASTNode fDestination;
@@ -715,8 +716,8 @@ public class ExtractMethodRefactoring extends Refactoring {
 		if (fDuplicates == null)
 			return 0;
 		int result=0;
-		for (int i= 0; i < fDuplicates.length; i++) {
-			if (!fDuplicates[i].isInvalidNode())
+		for (Match duplicate : fDuplicates) {
+			if (!duplicate.isInvalidNode())
 				result++;
 		}
 		return result;
@@ -783,8 +784,116 @@ public class ExtractMethodRefactoring extends Refactoring {
 			start= start.getParent();
 		}
 
-		fDuplicates= SnippetFinder.perform(start, fAnalyzer.getSelectedNodes());
-		fReplaceDuplicates= fDuplicates.length > 0 && ! fAnalyzer.isLiteralNodeSelected();
+		fDuplicates= findValidDuplicates(start);
+		fReplaceDuplicates= fDuplicates.size() > 0 && !fAnalyzer.isLiteralNodeSelected();
+	}
+
+	private List<SnippetFinder.Match> findValidDuplicates(ASTNode startNode) {
+		List<Match> duplicates= SnippetFinder.perform(startNode, fAnalyzer.getSelectedNodes());
+		List<SnippetFinder.Match> validDuplicates= new ArrayList<>();
+
+		for (Match duplicate : duplicates) {
+			if (duplicate != null && !duplicate.isInvalidNode()) {
+				try {
+					ASTNode[] nodes= duplicate.getNodes();
+					int duplicateStart= nodes[0].getStartPosition();
+					ASTNode lastNode= nodes[nodes.length - 1];
+					int duplicateEnd= lastNode.getStartPosition() + lastNode.getLength();
+					int duplicateLength= duplicateEnd - duplicateStart;
+					ExtractMethodAnalyzer analyzer= new ExtractMethodAnalyzer(fCUnit, Selection.createFromStartLength(duplicateStart, duplicateLength));
+					fRoot.accept(analyzer);
+					RefactoringStatus result= new RefactoringStatus();
+					result.merge(analyzer.checkInitialConditions(fImportRewriter));
+
+					if (!result.hasFatalError()) {
+						ITypeBinding originalReturnTypeBinding= fAnalyzer.getReturnTypeBinding();
+						ITypeBinding duplicateReturnTypeBinding= analyzer.getReturnTypeBinding();
+
+						if (originalReturnTypeBinding == null && duplicateReturnTypeBinding == null) {
+							validDuplicates.add(duplicate);
+						} else if (originalReturnTypeBinding != null && duplicateReturnTypeBinding != null) {
+							if (!originalReturnTypeBinding.equals(duplicateReturnTypeBinding)) {
+								if (duplicateReturnTypeBinding.equals(startNode.getAST().resolveWellKnownType("void"))) { //$NON-NLS-1$
+									// extracted snippet returns non-void and duplicate snippet returns void => OK 
+									validDuplicates.add(duplicate);
+								}
+							} else {
+								IVariableBinding originalReturnValBinding= fAnalyzer.getReturnValue();
+								IVariableBinding duplicateReturnValBinding= analyzer.getReturnValue();
+
+								if (originalReturnValBinding == null && duplicateReturnValBinding == null) {
+									validDuplicates.add(duplicate);
+								} else if (originalReturnValBinding != null && duplicateReturnValBinding != null) {
+									BodyDeclaration originalEnclosingBodyDeclaration= fAnalyzer.getEnclosingBodyDeclaration();
+									BodyDeclaration duplicateEnclosingBodyDeclaration= analyzer.getEnclosingBodyDeclaration();
+									VariableDeclaration originalReturnNode= ASTNodes.findVariableDeclaration(originalReturnValBinding, originalEnclosingBodyDeclaration);
+									VariableDeclaration duplicateReturnNode= ASTNodes.findVariableDeclaration(duplicateReturnValBinding, duplicateEnclosingBodyDeclaration);
+
+									if (originalReturnNode != null && duplicateReturnNode != null) {
+										boolean matches;
+										if (!fAnalyzer.getSelection().covers(originalReturnNode) && !analyzer.getSelection().covers(duplicateReturnNode)) {
+											// returned variables are defined outside of the selection => always OK
+											matches= true;
+										} else {
+											matches= matchesLocationInEnclosingBodyDecl(originalEnclosingBodyDeclaration, duplicateEnclosingBodyDeclaration, originalReturnNode, duplicateReturnNode);
+										}
+										
+										if (matches) {
+											validDuplicates.add(duplicate);
+										}
+									}
+								}
+							}
+						}
+					}
+				} catch (CoreException e) {
+					// consider as invalid duplicate
+				}
+			}
+		}
+		return validDuplicates;
+	}
+
+	private boolean matchesLocationInEnclosingBodyDecl(BodyDeclaration originalEnclosingBodyDeclaration, BodyDeclaration duplicateEnclosingBodyDeclaration,
+			VariableDeclaration originalReturnNode, VariableDeclaration duplicateReturnNode) {
+		boolean matches= true;
+		ASTNode original= originalReturnNode;
+		ASTNode dupliacte= duplicateReturnNode;
+
+		// walk up the parent chains to check if the location of the return nodes in their respective parent chains is same
+		do {
+			ASTNode originalParent= original.getParent();
+			ASTNode duplicateParent= dupliacte.getParent();
+			StructuralPropertyDescriptor originalLoc= original.getLocationInParent();
+			StructuralPropertyDescriptor duplicateLoc= dupliacte.getLocationInParent();
+
+			if (originalParent != null && duplicateParent != null
+					&& originalLoc.getNodeClass().equals(duplicateLoc.getNodeClass())
+					&& originalLoc.getId().equals(duplicateLoc.getId())) {
+				if (originalLoc.isChildListProperty() && duplicateLoc.isChildListProperty()) {
+					int indexOfOriginal= ((List<?>) originalParent.getStructuralProperty(originalLoc)).indexOf(original);
+					int indexOfDuplicate= ((List<?>) duplicateParent.getStructuralProperty(duplicateLoc)).indexOf(dupliacte);
+					if (indexOfOriginal != indexOfDuplicate) {
+						matches= false;
+						break;
+					}
+				}
+			} else {
+				matches= false;
+				break;
+			}
+
+			original= originalParent;
+			dupliacte= duplicateParent;
+
+			if ((originalEnclosingBodyDeclaration.equals(original) && !duplicateEnclosingBodyDeclaration.equals(dupliacte))
+					|| (!originalEnclosingBodyDeclaration.equals(original) && duplicateEnclosingBodyDeclaration.equals(dupliacte))) {
+				matches= false;
+				break;
+			}
+		} while (!originalEnclosingBodyDeclaration.equals(original) && !duplicateEnclosingBodyDeclaration.equals(dupliacte));
+
+		return matches;
 	}
 
 	private void initializeDestinations() {
@@ -927,8 +1036,7 @@ public class ExtractMethodRefactoring extends Refactoring {
 		TextEditGroup description= new TextEditGroup(label);
 		result.addTextEditGroup(description);
 
-		for (int d= 0; d < fDuplicates.length; d++) {
-			SnippetFinder.Match duplicate= fDuplicates[d];
+		for (Match duplicate : fDuplicates) {
 			if (!duplicate.isInvalidNode()) {
 				if (isDestinationReachable(duplicate.getEnclosingMethod())) {
 					ASTNode[] callNodes= createCallNodes(duplicate, modifiers);
@@ -949,8 +1057,7 @@ public class ExtractMethodRefactoring extends Refactoring {
 		if(!fReplaceDuplicates){
 			return false;
 		}
-		for(int i= 0;i < fDuplicates.length; i++) {
-			SnippetFinder.Match duplicate= fDuplicates[i];
+		for (Match duplicate : fDuplicates) {
 			if(!duplicate.isInvalidNode() && duplicate.isNodeInStaticContext()) {
 				return true;
 			}
diff --git a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/SnippetFinder.java b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/SnippetFinder.java
index 1597e66a0a..ae14c2ca5c 100644
--- a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/SnippetFinder.java
+++ b/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/SnippetFinder.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2016 IBM Corporation and others.
+ * Copyright (c) 2000, 2017 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -160,7 +160,7 @@ import org.eclipse.jdt.internal.corext.dom.GenericVisitor;
 		reset();
 	}
 
-	public static Match[] perform(ASTNode start, ASTNode[] snippet) {
+	public static List<Match> perform(ASTNode start, ASTNode[] snippet) {
 		Assert.isTrue(start instanceof AbstractTypeDeclaration || start instanceof AnonymousClassDeclaration);
 		SnippetFinder finder= new SnippetFinder(snippet);
 		start.accept(finder);
@@ -174,10 +174,10 @@ import org.eclipse.jdt.internal.corext.dom.GenericVisitor;
 				iter.remove();
 			}
 		}
-		return finder.fResult.toArray(new Match[finder.fResult.size()]);
+		return finder.fResult;
 	}
 
-	private static boolean isLeftHandSideOfAssignment(ASTNode node) {
+	static boolean isLeftHandSideOfAssignment(ASTNode node) {
 		Assignment assignment= (Assignment)ASTNodes.getParent(node, ASTNode.ASSIGNMENT);
 		if (assignment != null) {
 			Expression leftHandSide= assignment.getLeftHandSide();