Fix for Bug 407131 [1.8][dom ast]ASTRewrite support for

ReferenceExpression nodes family

9 files changed, 761 insertions, 24 deletions

diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java
index 9a8329506b..fd096d3876 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java
@@ -2823,7 +2823,7 @@ public void test0061() {
 			"----------\n" + 
 			"1. ERROR in X.java (at line 11)\n" + 
 			"	I i = Y::new;\n" + 
-			"	      ^^^^^^^\n" + 
+			"	      ^^^^^^\n" + 
 			"Constructor references are allowed only at source level 1.8 or above\n" + 
 			"----------\n";
 
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java
index 556fca2cdc..e2369c83d4 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java
@@ -1500,7 +1500,7 @@ public class GrammarCoverageTests308 extends AbstractRegressionTest {
 				"----------\n" + 
 				"2. ERROR in X.java (at line 12)\n" + 
 				"	i = @Marker W<@Marker Integer>::<@Marker String> new;\n" + 
-				"	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
+				"	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
 				"The target type of this expression must be a functional interface\n" + 
 				"----------\n" + 
 				"3. ERROR in X.java (at line 12)\n" + 
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java
index f3221c3d9d..d1bfa692a2 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java
@@ -1250,7 +1250,7 @@ public void test037() {
 			"----------\n" + 
 			"3. ERROR in X.java (at line 8)\n" + 
 			"	System.out.println(\"Constructor Reference in illegal context: \" + String::new);\n" + 
-			"	                                                                  ^^^^^^^^^^^^\n" + 
+			"	                                                                  ^^^^^^^^^^^\n" + 
 			"The target type of this expression must be a functional interface\n" + 
 			"----------\n" + 
 			"4. ERROR in X.java (at line 10)\n" + 
@@ -4262,7 +4262,7 @@ public void test384750m() {
 					"----------\n" + 
 					"1. ERROR in X.java (at line 12)\n" + 
 					"	I i3 = ArrayList<Integer>::new;\n" + 
-					"	       ^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
+					"	       ^^^^^^^^^^^^^^^^^^^^^^^\n" + 
 					"The constructed object of type ArrayList<Integer> is incompatible with the descriptor\'s return type: List<String>\n" + 
 					"----------\n" + 
 					"2. ERROR in X.java (at line 13)\n" + 
@@ -4305,12 +4305,12 @@ public void test384750n() {
 					"----------\n" + 
 					"1. ERROR in X.java (at line 7)\n" + 
 					"	I i1 = ArrayList<String>[]::new;\n" + 
-					"	       ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
+					"	       ^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
 					"Cannot create a generic array of ArrayList<String>\n" + 
 					"----------\n" + 
 					"2. ERROR in X.java (at line 8)\n" + 
 					"	I i2 = List<String>[]::new;\n" + 
-					"	       ^^^^^^^^^^^^^^^^^^^^\n" + 
+					"	       ^^^^^^^^^^^^^^^^^^^\n" + 
 					"Cannot create a generic array of List<String>\n" + 
 					"----------\n");
 }
@@ -4367,27 +4367,27 @@ public void test384750o() {
 					"----------\n" + 
 					"1. ERROR in X.java (at line 34)\n" + 
 					"	I i = List[]::new;\n" + 
-					"	      ^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^\n" + 
 					"Incompatible parameter list for array constructor. Expected (int), but found ()\n" + 
 					"----------\n" + 
 					"2. ERROR in X.java (at line 35)\n" + 
 					"	J j = ArrayList[]::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^^^\n" + 
 					"Incompatible parameter list for array constructor. Expected (int), but found (long)\n" + 
 					"----------\n" + 
 					"3. ERROR in X.java (at line 36)\n" + 
 					"	K k = ArrayList[]::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^^^\n" + 
 					"Incompatible parameter list for array constructor. Expected (int), but found (String, long)\n" + 
 					"----------\n" + 
 					"4. ERROR in X.java (at line 42)\n" + 
 					"	Q q = ArrayList[]::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^^^\n" + 
 					"Incompatible parameter list for array constructor. Expected (int), but found (Float)\n" + 
 					"----------\n" + 
 					"5. ERROR in X.java (at line 43)\n" + 
 					"	R r = ArrayList[][][]::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^^^^^^^\n" + 
 					"Constructed array ArrayList[][][] cannot be assigned to List<String>[] as required in the interface descriptor  \n" + 
 					"----------\n");
 }
@@ -4631,17 +4631,17 @@ public void test384750w() {
 					"----------\n" + 
 					"1. ERROR in X.java (at line 23)\n" + 
 					"	J j = X<Integer>::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^^\n" + 
 					"The constructed object of type X<Integer> is incompatible with the descriptor\'s return type: X<String>\n" + 
 					"----------\n" + 
 					"2. ERROR in X.java (at line 24)\n" + 
 					"	K k = X::new;\n" + 
-					"	      ^^^^^^^\n" + 
+					"	      ^^^^^^\n" + 
 					"The target type of this expression must be a functional interface\n" + 
 					"----------\n" + 
 					"3. ERROR in X.java (at line 26)\n" + 
 					"	M m = X<String>::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^\n" + 
 					"The type X<String> does not define X(String) that is applicable here\n" + 
 					"----------\n");
 }
@@ -4678,22 +4678,22 @@ public void test384750x() {
 					"----------\n" + 
 					"1. ERROR in X.java (at line 19)\n" + 
 					"	I i = X::new;\n" + 
-					"	      ^^^^^^^\n" + 
+					"	      ^^^^^^\n" + 
 					"Unhandled exception type IOException\n" + 
 					"----------\n" + 
 					"2. ERROR in X.java (at line 19)\n" + 
 					"	I i = X::new;\n" + 
-					"	      ^^^^^^^\n" + 
+					"	      ^^^^^^\n" + 
 					"Unhandled exception type FileNotFoundException\n" + 
 					"----------\n" + 
 					"3. ERROR in X.java (at line 20)\n" + 
 					"	J j = X<Integer>::new;\n" + 
-					"	      ^^^^^^^^^^^^^^^^\n" + 
+					"	      ^^^^^^^^^^^^^^^\n" + 
 					"The constructed object of type X<Integer> is incompatible with the descriptor\'s return type: X<String>\n" + 
 					"----------\n" + 
 					"4. ERROR in X.java (at line 21)\n" + 
 					"	K k = X::new;\n" + 
-					"	      ^^^^^^^\n" + 
+					"	      ^^^^^^\n" + 
 					"Unhandled exception type IOException\n" + 
 					"----------\n");
 }
@@ -6409,7 +6409,7 @@ public void test406588() {
 			"----------\n" + 
 			"1. ERROR in X.java (at line 10)\n" + 
 			"	this(Z::new);\n" + 
-			"	     ^^^^^^^\n" + 
+			"	     ^^^^^^\n" + 
 			"No enclosing instance of the type X.Y is accessible in scope\n" + 
 			"----------\n");
 }
@@ -6432,7 +6432,7 @@ public void test406586() {
 			"----------\n" + 
 			"1. ERROR in X.java (at line 8)\n" + 
 			"	I i = Y::new;\n" + 
-			"	      ^^^^^^^\n" + 
+			"	      ^^^^^^\n" + 
 			"No enclosing instance of the type X is accessible in scope\n" + 
 			"----------\n");
 }
@@ -6522,12 +6522,12 @@ public void test406773() {
 			"----------\n" + 
 			"2. WARNING in X.java (at line 10)\n" + 
 			"	I i = X::new;\n" + 
-			"	      ^^^^^^^\n" + 
+			"	      ^^^^^^\n" + 
 			"Access to enclosing constructor X(int) is emulated by a synthetic accessor method\n" + 
 			"----------\n" + 
 			"3. ERROR in X.java (at line 12)\n" + 
 			"	i = Y::new;\n" + 
-			"	    ^^^^^^^\n" + 
+			"	    ^^^^^^\n" + 
 			"No enclosing instance of the type X is accessible in scope\n" + 
 			"----------\n",
 			null /* no extra class libraries */,
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
index c99f56652d..296e146817 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
@@ -1801,7 +1801,7 @@ public class ASTConverter18Test extends ConverterTestSetup {
 		expression = fragment.getInitializer();
 		assertTrue(expression instanceof CreationReference);
 		CreationReference creationReference = (CreationReference) expression;
-		checkSourceRange(creationReference, "@Marker W<@Marker Integer> :: <String> new ", contents);
+		checkSourceRange(creationReference, "@Marker W<@Marker Integer> :: <String> new", contents);
 		typeBinding = creationReference.resolveTypeBinding();
 		assertNotNull(typeBinding);
 		methodBinding = creationReference.resolveMethodBinding();
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingReferenceExpressionTest.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingReferenceExpressionTest.java
new file mode 100644
index 0000000000..75dd62cce6
--- /dev/null
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingReferenceExpressionTest.java
@@ -0,0 +1,624 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * This is an implementation of an early-draft specification developed under the Java
+ * Community Process (JCP) and is made available for testing and evaluation purposes
+ * only. The code is not compatible with any specification of the JCP.
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.core.tests.rewrite.describing;
+
+import java.util.Iterator;
+
+import junit.framework.Test;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.dom.*;
+import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
+
+public class ASTRewritingReferenceExpressionTest extends ASTRewritingTest {
+
+	public ASTRewritingReferenceExpressionTest(String name) {
+		super(name);
+	}
+
+	public ASTRewritingReferenceExpressionTest(String name, int apiLevel) {
+		super(name, apiLevel);
+	}
+
+	public static Test suite() {
+		return createSuite(ASTRewritingReferenceExpressionTest.class);
+	}
+
+	/**
+	 * tests various aspects of CreationReference (Constructor Method Reference) with ClassType as lhs
+	 * @throws Exception
+	 */
+	public void testReferenceExpressions_test001_since_8() throws Exception {
+		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test407131", false, null);
+		String contents = "package test407131;\n" +
+				"\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	static class Z {\n" +
+				"		public Z(int x) {\n" +
+				"			System.out.print(x);\n" +
+				"		}\n" +
+				"		public void foo(int x) {\n" +
+				"			System.out.print(x);\n" +
+				"		}\n" +
+				"	}\n" +
+				"}\n" +
+				"class W<T> {\n" +
+				"	public W(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		J j1 = W <Integer> :: <String> new;\n" +
+				"		J j2 = W <Integer> :: <String> new ;\n" +
+				"		J j3 = W <Integer> :: <String, Integer> new ;\n" +
+				"		J j4 = W <Integer> :: <String> new ;\n" +
+				"		J j5 = W <Integer> :: <String> new ;\n" +
+				"		J j6 = W <Integer> :: new;\n" +
+				"		J j7 = W <Integer> :: new;\n" +
+				"		J j8 = W <Integer> :: new;\n" +
+				"	}\n" +
+				"}\n" +
+				"\n" ;
+		StringBuffer buf= new StringBuffer(contents);
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+		CompilationUnit astRoot= createAST(cu);
+		ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+		AST ast= astRoot.getAST();
+
+		TypeDeclaration typedeclaration= findTypeDeclaration(astRoot, "X");
+
+		MethodDeclaration methodDecl= findMethodDeclaration(typedeclaration, "main");
+		{
+			// case 1: replace the type argument.
+			VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(0);
+			VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			CreationReference creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			TypeParameter typeParameter= ast.newTypeParameter();
+			typeParameter.setName(ast.newSimpleName("Integer"));			
+			ListRewrite listRewrite = rewrite.getListRewrite(creationReference, CreationReference.TYPE_ARGUMENTS_PROPERTY);
+			listRewrite.replace((ASTNode)(creationReference.typeArguments().get(0)), typeParameter, null);
+			
+			// case 2: add a type argument.
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(1);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			typeParameter= ast.newTypeParameter();
+			typeParameter.setName(ast.newSimpleName("Integer"));			
+			listRewrite = rewrite.getListRewrite(creationReference, CreationReference.TYPE_ARGUMENTS_PROPERTY);
+			listRewrite.insertLast(typeParameter, null);
+			
+			// case 3: delete a type argument.
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(2);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			listRewrite = rewrite.getListRewrite(creationReference, CreationReference.TYPE_ARGUMENTS_PROPERTY);
+			listRewrite.remove((ASTNode)(creationReference.typeArguments().get(1)), null);
+
+			// case 4: do not change existing type arg - implicit test case.
+			// case 5: delete the only type argument.
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(4);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			listRewrite = rewrite.getListRewrite(creationReference, CreationReference.TYPE_ARGUMENTS_PROPERTY);
+			for (Iterator iter= listRewrite.getOriginalList().iterator(); iter.hasNext(); ) {//loop added for general case - iterates once here.
+				ASTNode typeArgument= (ASTNode) iter.next();
+				listRewrite.remove(typeArgument, null);
+			}
+
+			// case 6: do not change a CreationReference originally having no type arguments - implicit test case.
+			// case 7: Insert a type argument for a CreationReference originally having no type arguments.
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(6);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			listRewrite = rewrite.getListRewrite(creationReference, CreationReference.TYPE_ARGUMENTS_PROPERTY);
+			typeParameter= ast.newTypeParameter();
+			typeParameter.setName(ast.newSimpleName("String"));			
+			listRewrite.insertFirst(typeParameter, null);
+
+			// case 8: change a CreationReference to a TypeMethodReference.
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(7);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			SimpleType simpleType = ast.newSimpleType(ast.newQualifiedName(ast.newSimpleName("Y"), ast.newSimpleName("Z")));
+			rewrite.replace(creationReference.getType(), simpleType, null);
+		}
+		
+		String preview= evaluateRewrite(cu, rewrite);
+		contents = "package test407131;\n" +
+				"\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	static class Z {\n" +
+				"		public Z(int x) {\n" +
+				"			System.out.print(x);\n" +
+				"		}\n" +
+				"		public void foo(int x) {\n" +
+				"			System.out.print(x);\n" +
+				"		}\n" +
+				"	}\n" +
+				"}\n" +
+				"class W<T> {\n" +
+				"	public W(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		J j1 = W <Integer> :: <Integer> new;\n" +
+				"		J j2 = W <Integer> :: <String, Integer> new ;\n" +
+				"		J j3 = W <Integer> :: <String> new ;\n" +
+				"		J j4 = W <Integer> :: <String> new ;\n" +
+				"		J j5 = W <Integer> :: new ;\n" +
+				"		J j6 = W <Integer> :: new;\n" +
+				"		J j7 = W <Integer> ::<String> new;\n" +
+				"		J j8 = Y.Z :: new;\n" +
+				"	}\n" +
+				"}\n" +
+				"\n" ;
+		buf= new StringBuffer(contents);
+		assertEqualString(preview, buf.toString());
+	}
+	
+	/**
+	 * tests various aspects of CreationReference (Constructor Method Reference) with ArrayType as lhs
+	 * @throws Exception
+	 */
+	public void testReferenceExpressions_test002_since_8() throws Exception {
+		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test407131", false, null);
+		String contents = "package test407131;\n" +
+				"interface I {\n" +
+				"	Object foo(int x);\n" +
+				"}\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		I i1 = int[] :: new;\n" +
+				"	}\n" +
+				"}\n" +
+				"\n" ;
+		StringBuffer buf= new StringBuffer(contents);
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+		CompilationUnit astRoot= createAST(cu);
+		ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+		AST ast= astRoot.getAST();
+
+		TypeDeclaration typedeclaration= findTypeDeclaration(astRoot, "X");
+
+		MethodDeclaration methodDecl= findMethodDeclaration(typedeclaration, "main");
+		{
+			// replace the primitive type of lhs from int to char.
+			VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(0);
+			VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			CreationReference creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			ArrayType arrayType = (ArrayType) creationReference.getType();
+			rewrite.replace(arrayType.getElementType(), ast.newPrimitiveType(PrimitiveType.CHAR), null);
+		}
+		String preview= evaluateRewrite(cu, rewrite);
+		contents = "package test407131;\n" +
+				"interface I {\n" +
+				"	Object foo(int x);\n" +
+				"}\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		I i1 = char[] :: new;\n" +
+				"	}\n" +
+				"}\n" +
+				"\n" ;
+		buf= new StringBuffer(contents);
+		assertEqualString(preview, buf.toString());
+	}
+	
+	/**
+	 * tests various aspects of {@link ExpressionMethodReference}
+	 * @throws Exception
+	 */
+	public void testReferenceExpressions_test003_since_8() throws Exception {
+		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test407131", false, null);
+		String contents = "package test407131;\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	public void foo(int x) {}\n" +
+				"}\n" +
+				"class Z {\n" +
+				"	public void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		Y y = new Y();\n" +
+				"		Z z = new Z();\n" +
+				"		J j1 = y :: foo;\n" +
+				"		J j2 = z :: <String> bar;\n" +
+				"	}\n" +
+				"}\n" +
+				"\n" ;
+		StringBuffer buf= new StringBuffer(contents);
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+		CompilationUnit astRoot= createAST(cu);
+		ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+		AST ast= astRoot.getAST();
+
+		TypeDeclaration typedeclaration= findTypeDeclaration(astRoot, "X");
+
+		MethodDeclaration methodDecl= findMethodDeclaration(typedeclaration, "main");
+		{
+			// replace the lhs and the rhs.
+			VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(2);
+			VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			ExpressionMethodReference expressionMethodReference = (ExpressionMethodReference) variableDeclarationFragment.getInitializer();
+			TypeParameter typeParameter= ast.newTypeParameter();
+			typeParameter.setName(ast.newSimpleName("String"));			
+			rewrite.replace(expressionMethodReference.getExpression(), ast.newSimpleName("z"), null);
+			rewrite.getListRewrite(expressionMethodReference, ExpressionMethodReference.TYPE_ARGUMENTS_PROPERTY).insertFirst(typeParameter, null);
+			rewrite.replace(expressionMethodReference.getName(), ast.newSimpleName("bar"), null);
+			
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(3);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			expressionMethodReference = (ExpressionMethodReference) variableDeclarationFragment.getInitializer();
+			rewrite.replace(expressionMethodReference.getExpression(), ast.newSimpleName("y"), null);
+			ASTNode typeArgument = (ASTNode) expressionMethodReference.typeArguments().get(0);
+			rewrite.getListRewrite(expressionMethodReference, ExpressionMethodReference.TYPE_ARGUMENTS_PROPERTY).remove(typeArgument, null);
+			rewrite.replace(expressionMethodReference.getName(), ast.newSimpleName("foo"), null);
+			
+		}
+		String preview= evaluateRewrite(cu, rewrite);
+		contents = "package test407131;\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	public void foo(int x) {}\n" +
+				"}\n" +
+				"class Z {\n" +
+				"	public void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		Y y = new Y();\n" +
+				"		Z z = new Z();\n" +
+				"		J j1 = z ::<String> bar;\n" +
+				"		J j2 = y :: foo;\n" +
+				"	}\n" +
+				"}\n" +
+				"\n" ;
+		buf= new StringBuffer(contents);
+		assertEqualString(preview, buf.toString());
+	}
+	
+	/**
+	 * tests various aspects of {@link TypeMethodReference}
+	 * @throws Exception
+	 */
+	public void testReferenceExpressions_test004_since_8() throws Exception {
+		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test407131", false, null);
+		String contents = "package test407131;\n" +
+				"package test407131;\n" +
+				"\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	static class Z {\n" +
+				"		public Z(int x) {}\n" +
+				"		public static void foo(int x) {}\n" +
+				"	}\n" +
+				"}\n" +
+				"class W<T> {\n" +
+				"	public static void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		J j1 = Y.@Marker Z :: foo;\n" +
+				"		J j2 = @Marker W :: <Integer> bar;\n" +
+				"	}\n" +
+				"@Target (ElementType.TYPE_USE)\n" +
+				"@interface @Marker {}\n" +
+				"}\n" ;
+		StringBuffer buf= new StringBuffer(contents);
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+		CompilationUnit astRoot= createAST(cu);
+		ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+		AST ast= astRoot.getAST();
+
+		TypeDeclaration typedeclaration= findTypeDeclaration(astRoot, "X");
+
+		MethodDeclaration methodDecl= findMethodDeclaration(typedeclaration, "main");
+		{
+			// replace the lhs and the rhs.
+			VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(0);
+			VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			TypeMethodReference typeMethodReference = (TypeMethodReference) variableDeclarationFragment.getInitializer();
+			TypeParameter typeParameter= ast.newTypeParameter();
+			typeParameter.setName(ast.newSimpleName("Integer"));
+			Type newType = ast.newSimpleType(ast.newSimpleName("W"));
+			rewrite.replace(typeMethodReference.getType(), newType, null);
+			rewrite.getListRewrite(typeMethodReference, TypeMethodReference.TYPE_ARGUMENTS_PROPERTY).insertFirst(typeParameter, null);
+			rewrite.replace(typeMethodReference.getName(), ast.newSimpleName("bar"), null);
+			
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(1);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			typeMethodReference = (TypeMethodReference) variableDeclarationFragment.getInitializer();
+			newType = ast.newSimpleType(ast.newQualifiedName(ast.newSimpleName("Y"),ast.newSimpleName("Z")));
+			rewrite.replace(typeMethodReference.getType(), newType, null);
+			ASTNode typeArgument = (ASTNode) typeMethodReference.typeArguments().get(0);
+			rewrite.getListRewrite(typeMethodReference, TypeMethodReference.TYPE_ARGUMENTS_PROPERTY).remove(typeArgument, null);
+			rewrite.replace(typeMethodReference.getName(), ast.newSimpleName("foo"), null);			
+		}
+		String preview= evaluateRewrite(cu, rewrite);
+		contents = "package test407131;\n" +
+				"package test407131;\n" +
+				"\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	static class Z {\n" +
+				"		public Z(int x) {}\n" +
+				"		public static void foo(int x) {}\n" +
+				"	}\n" +
+				"}\n" +
+				"class W<T> {\n" +
+				"	public static void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X {\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public static void main (String [] args) {\n" +
+				"		J j1 = W ::<Integer> bar;\n" +
+				"		J j2 = Y.Z :: foo;\n" +
+				"	}\n" +
+				"@Target (ElementType.TYPE_USE)\n" +
+				"@interface @Marker {}\n" +
+				"}\n" ;
+		buf= new StringBuffer(contents);
+		assertEqualString(preview, buf.toString());
+	}
+	
+	/**
+	 * tests various aspects of SuperMethodReference
+	 * @throws Exception
+	 */
+	public void testReferenceExpressions_test005_since_8() throws Exception {
+		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test407131", false, null);
+		String contents = "package test407131;\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"\n" +
+				"class XX {\n" +
+				"	public void foo(int x) {}\n" +
+				"	public void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X extends XX {\n" +
+				"       @SuppressWarnings(\"unused\")\n" +
+				"       public  void bar(int i) {\n" +
+				"           J jx = super :: <Integer> foo;\n" +
+				"           J jz = X.super :: bar;\n" +
+				"       }\n" +
+				"       public static void main (String [] args) {}\n" +
+				"}\n" +
+				"\n" ;
+		StringBuffer buf= new StringBuffer(contents);
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+		CompilationUnit astRoot= createAST(cu);
+		ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+		AST ast= astRoot.getAST();
+
+		TypeDeclaration typedeclaration= findTypeDeclaration(astRoot, "X");
+
+		MethodDeclaration methodDecl= findMethodDeclaration(typedeclaration, "bar");
+		{
+			// replace the lhs and the rhs, add/delete type arguments.
+			VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(0);
+			VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			SuperMethodReference superMethodReference = (SuperMethodReference) variableDeclarationFragment.getInitializer();
+			rewrite.set(superMethodReference, SuperMethodReference.QUALIFIER_PROPERTY, ast.newSimpleName("X"), null);
+			ASTNode typeArgument = (ASTNode) superMethodReference.typeArguments().get(0);
+			rewrite.getListRewrite(superMethodReference, SuperMethodReference.TYPE_ARGUMENTS_PROPERTY).remove(typeArgument, null);
+			rewrite.replace(superMethodReference.getName(), ast.newSimpleName("bar"), null);
+			
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(1);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			superMethodReference = (SuperMethodReference) variableDeclarationFragment.getInitializer();
+			rewrite.remove(superMethodReference.getQualifier(), null);
+			TypeParameter typeParameter= ast.newTypeParameter();
+			typeParameter.setName(ast.newSimpleName("String"));
+			rewrite.getListRewrite(superMethodReference, SuperMethodReference.TYPE_ARGUMENTS_PROPERTY).insertFirst(typeParameter, null);
+			rewrite.replace(superMethodReference.getName(), ast.newSimpleName("foo"), null);
+			
+		}
+		String preview = evaluateRewrite(cu, rewrite);
+		contents = "package test407131;\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"\n" +
+				"class XX {\n" +
+				"	public void foo(int x) {}\n" +
+				"	public void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X extends XX {\n" +
+				"       @SuppressWarnings(\"unused\")\n" +
+				"       public  void bar(int i) {\n" +
+				"           J jx = X.super :: bar;\n" +
+				"           J jz = super ::<String> foo;\n" +
+				"       }\n" +
+				"       public static void main (String [] args) {}\n" +
+				"}\n" +
+				"\n" ;
+		buf = new StringBuffer(contents);
+		assertEqualString(preview, buf.toString());
+	}
+	/**
+	 * tests cross rewriting - changing from one member of reference expressions to another type.
+	 * @throws Exception
+	 */
+	public void testReferenceExpressions_test006_since_8() throws Exception {
+		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test407131", false, null);
+		String contents = "package test407131;\n" +
+				"import java.lang.annotation.*;\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	static class Z {\n" +
+				"		public Z(int x) {}\n" +
+				"		public static void foo(int x) {}\n" +
+				"	}\n" +
+				"}\n" +
+				"class W<T> {\n" +
+				"	public W(int x) {}\n" +
+				"	public static void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"class XX {\n" +
+				"	public void foo(int x) {}\n" +
+				"	public void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X extends XX {\n" +
+				"	public static void main (String [] args) {}\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public void bar () {\n" +
+				"		J j1 = W <Integer> :: <String> new;\n" +
+				"		J j2 = Y.Z :: new;\n" +
+				"		J j3 = Y.@Marker Z :: foo;\n" +
+				"		J jx = super :: foo;\n" +
+				"		J jz = X.super :: bar;\n" +
+				"	}\n" +
+				"}\n" +
+				"@Target (ElementType.TYPE_USE)\n" +
+				"@interface Marker {}\n" +
+				"}\n";
+		StringBuffer buf= new StringBuffer(contents);
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+		CompilationUnit astRoot= createAST(cu);
+		ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+		AST ast= astRoot.getAST();
+
+		TypeDeclaration typedeclaration= findTypeDeclaration(astRoot, "X");
+
+		MethodDeclaration methodDecl= findMethodDeclaration(typedeclaration, "bar");
+		{
+			// case 1: creationReference to TypeMethodReference
+			VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(0);
+			VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			CreationReference creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			TypeMethodReference typeMethodReference = ast.newTypeMethodReference();
+			QualifiedType qualifiedType = ast.newQualifiedType(ast.newSimpleType(ast.newSimpleName("Y")), ast.newSimpleName("Z"));
+			MarkerAnnotation markerAnnotation = ast.newMarkerAnnotation();
+			markerAnnotation.setTypeName(ast.newSimpleName("Marker"));
+			qualifiedType.annotations().add(markerAnnotation);
+			typeMethodReference.setType(qualifiedType);
+			typeMethodReference.setName(ast.newSimpleName("foo"));
+			rewrite.replace(creationReference, typeMethodReference, null);
+			
+			// case 2: CreationReference to SuperMethodReference
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(1);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			creationReference = (CreationReference) variableDeclarationFragment.getInitializer();
+			SuperMethodReference superMethodReference = ast.newSuperMethodReference();
+			superMethodReference.setName(ast.newSimpleName("foo"));
+			rewrite.replace(creationReference, superMethodReference, null);
+			
+			// case 3: TypeMethodReference to SuperMethodReference
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(2);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			typeMethodReference = (TypeMethodReference) variableDeclarationFragment.getInitializer();
+			superMethodReference = ast.newSuperMethodReference();
+			superMethodReference.setName(ast.newSimpleName("bar"));
+			superMethodReference.setQualifier(ast.newSimpleName("X"));
+			rewrite.replace(typeMethodReference, superMethodReference, null);			
+			
+			// case 4: SuperMethodReference to CreationMethodReference
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(3);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			superMethodReference = (SuperMethodReference) variableDeclarationFragment.getInitializer();
+			ParameterizedType parameterizedType = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("W")));
+			parameterizedType.typeArguments().add(ast.newSimpleType(ast.newSimpleName("Integer")));
+			creationReference = ast.newCreationReference();
+			creationReference.setType(parameterizedType);
+			creationReference.typeArguments().add(ast.newSimpleType(ast.newSimpleName("String")));
+			rewrite.replace(superMethodReference, creationReference, null);			
+			
+			// case 5: SuperMethodReference to ExpressionMethodReference
+			variableDeclarationStatement = (VariableDeclarationStatement) methodDecl.getBody().statements().get(4);
+			variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
+			superMethodReference = (SuperMethodReference) variableDeclarationFragment.getInitializer();
+			ExpressionMethodReference expressionMethodReference = ast.newExpressionMethodReference();
+			expressionMethodReference.setExpression(ast.newQualifiedName(ast.newSimpleName("Y"), ast.newSimpleName("Z")));
+			expressionMethodReference.setName(ast.newSimpleName("foo"));
+			rewrite.replace(superMethodReference, expressionMethodReference, null);			
+			
+		}
+		
+		String preview= evaluateRewrite(cu, rewrite);
+		contents = "package test407131;\n" +
+				"import java.lang.annotation.*;\n" +
+				"interface J {\n" +
+				"	void foo(int x);\n" +
+				"}\n" +
+				"class Y {\n" +
+				"	static class Z {\n" +
+				"		public Z(int x) {}\n" +
+				"		public static void foo(int x) {}\n" +
+				"	}\n" +
+				"}\n" +
+				"class W<T> {\n" +
+				"	public W(int x) {}\n" +
+				"	public static void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"class XX {\n" +
+				"	public void foo(int x) {}\n" +
+				"	public void bar(int x) {}\n" +
+				"}\n" +
+				"\n" +
+				"public class X extends XX {\n" +
+				"	public static void main (String [] args) {}\n" +
+				"	@SuppressWarnings(\"unused\")\n" +
+				"	public void bar () {\n" +
+				"		J j1 = Y.@Marker Z::foo;\n" +
+				"		J j2 = super::foo;\n" +
+				"		J j3 = X.super::bar;\n" +
+				"		J jx = W<Integer>::<String> new;\n" +
+				"		J jz = Y.Z::foo;\n" +
+				"	}\n" +
+				"}\n" +
+				"@Target (ElementType.TYPE_USE)\n" +
+				"@interface Marker {}\n" +
+				"}\n";
+		buf= new StringBuffer(contents);
+		assertEqualString(preview, buf.toString());
+	}	
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java
index 4da48967e3..e371b4d075 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java
@@ -115,6 +115,7 @@ public class ASTRewritingTest extends AbstractJavaModelTests {
 		suite.addTest(ASTRewritePropertyTest.suite());
 		suite.addTest(ASTRewritingPackageDeclTest.suite());
 		suite.addTest(ASTRewritingLambdaExpressionTest.suite());		
+		suite.addTest(ASTRewritingReferenceExpressionTest.suite());		
 		suite.addTest(SourceModifierTest.suite());
 		suite.addTest(ImportRewriteTest.suite());
 		return suite;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
index 0fd892cb9f..82ba6fa5f3 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
@@ -7991,7 +7991,7 @@ protected void consumeIdentifierOrNew(boolean newForm) {
 	// IdentifierOrNew ::= 'new'
 	if (newForm) {
 		int newStart = this.intStack[this.intPtr--];
-		pushIdentifier(ConstantPool.Init, (((long) newStart << 32)) + (newStart + 3));
+		pushIdentifier(ConstantPool.Init, (((long) newStart << 32)) + (newStart + 2));
 	}
 }
 protected void consumeEmptyTypeArguments() {
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
index fd3b1b34fc..6cf44a92e9 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
@@ -2428,6 +2428,29 @@ public final class ASTRewriteAnalyzer extends ASTVisitor {
 		return false;
 	}
 
+	private void visitReferenceTypeArguments(ASTNode node, StructuralPropertyDescriptor childProperty, int pos) {
+		if (isChanged(node, childProperty)) {
+			try {
+				pos = getScanner().getTokenEndOffset(TerminalTokens.TokenNameCOLON_COLON, pos);
+				rewriteOptionalTypeParameters(node, childProperty, pos, Util.EMPTY_STRING, false, false);
+			} catch (CoreException e) {
+				handleException(e);
+			}
+		}
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(CreationReference)
+	 */
+	public boolean visit(CreationReference node) {
+		if (!hasChildrenChanges(node)) {
+			return doVisitUnchangedChildren(node);
+		}
+		int pos= rewriteRequiredNode(node, CreationReference.TYPE_PROPERTY);
+		visitReferenceTypeArguments(node, CreationReference.TYPE_ARGUMENTS_PROPERTY, pos);
+		return false;
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(DoStatement)
 	 */
@@ -3895,6 +3918,20 @@ public final class ASTRewriteAnalyzer extends ASTVisitor {
 		rewriteParagraphList(node, EnumDeclaration.BODY_DECLARATIONS_PROPERTY, pos, indent, -1, 2);
 		return false;
 	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(ExpressionMethodReference)
+	 */
+	public boolean visit(ExpressionMethodReference node) {
+		if (!hasChildrenChanges(node)) {
+			return doVisitUnchangedChildren(node);
+		}
+		int pos= rewriteRequiredNode(node, ExpressionMethodReference.EXPRESSION_PROPERTY);
+		visitReferenceTypeArguments(node, ExpressionMethodReference.TYPE_ARGUMENTS_PROPERTY, pos);
+		rewriteRequiredNode(node, ExpressionMethodReference.NAME_PROPERTY);
+		return false;
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MarkerAnnotation)
 	 */
@@ -4018,6 +4055,33 @@ public final class ASTRewriteAnalyzer extends ASTVisitor {
 		rewriteRequiredNode(node, SingleMemberAnnotation.VALUE_PROPERTY);
 		return false;
 	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(SuperMethodReference)
+	 */
+	public boolean visit(SuperMethodReference node) {
+		if (!hasChildrenChanges(node)) {
+			return doVisitUnchangedChildren(node);
+		}
+		int pos = rewriteOptionalQualifier(node, SuperMethodReference.QUALIFIER_PROPERTY, node.getStartPosition());
+		visitReferenceTypeArguments(node, SuperMethodReference.TYPE_ARGUMENTS_PROPERTY, pos);
+		rewriteRequiredNode(node, SuperMethodReference.NAME_PROPERTY);
+		return false;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(TypeMethodReference)
+	 */
+	public boolean visit(TypeMethodReference node) {
+		if (!hasChildrenChanges(node)) {
+			return doVisitUnchangedChildren(node);
+		}
+		int pos= rewriteRequiredNode(node, TypeMethodReference.TYPE_PROPERTY);
+		visitReferenceTypeArguments(node, TypeMethodReference.TYPE_ARGUMENTS_PROPERTY, pos);
+		rewriteRequiredNode(node, TypeMethodReference.NAME_PROPERTY);
+		return false;
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeParameter)
 	 */
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java
index 29e8813cea..20f66e3874 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java
@@ -471,6 +471,17 @@ public class ASTRewriteFlattener extends ASTVisitor {
 	}
 
 	/*
+	 * @see ASTVisitor#visit(CreationReference)
+	 */
+	public boolean visit(CreationReference node) {
+		getChildNode(node, CreationReference.TYPE_PROPERTY).accept(this);
+		this.result.append("::"); //$NON-NLS-1$
+		visitList(node, CreationReference.TYPE_ARGUMENTS_PROPERTY, Util.EMPTY_STRING, String.valueOf('<'), String.valueOf('>'));
+		this.result.append("new"); //$NON-NLS-1$
+		return false;
+	}
+
+	/*
 	 * @see ASTVisitor#visit(DoStatement)
 	 */
 	public boolean visit(DoStatement node) {
@@ -1366,6 +1377,17 @@ public class ASTRewriteFlattener extends ASTVisitor {
 		return false;
 	}
 	/*
+	 * @see ASTVisitor#visit(ExpressionMethodReference)
+	 */
+	public boolean visit(ExpressionMethodReference node) {
+		getChildNode(node, ExpressionMethodReference.EXPRESSION_PROPERTY).accept(this);
+		this.result.append("::"); //$NON-NLS-1$
+		visitList(node, ExpressionMethodReference.TYPE_ARGUMENTS_PROPERTY, Util.EMPTY_STRING, String.valueOf('<'), String.valueOf('>'));
+		node.getName().accept(this);
+		return false;
+	}
+
+	/*
 	 * @see ASTVisitor#visit(MarkerAnnotation)
 	 * @since 3.0
 	 */
@@ -1459,6 +1481,32 @@ public class ASTRewriteFlattener extends ASTVisitor {
 		return false;
 	}
 
+	/*
+	 * @see ASTVisitor#visit(SuperMethodReference)
+	 */
+	public boolean visit(SuperMethodReference node) {
+		ASTNode qualifier = getChildNode(node, SuperMethodReference.QUALIFIER_PROPERTY);
+		if (qualifier != null) {
+			qualifier.accept(this);
+			this.result.append('.');
+		}
+		this.result.append("super ::"); //$NON-NLS-1$
+		visitList(node, SuperMethodReference.TYPE_ARGUMENTS_PROPERTY, Util.EMPTY_STRING, String.valueOf('<'), String.valueOf('>'));
+		node.getName().accept(this);
+		return false;
+	}
+
+	/*
+	 * @see ASTVisitor#visit(TypeMethodReference)
+	 */
+	public boolean visit(TypeMethodReference node) {
+		getChildNode(node, TypeMethodReference.TYPE_PROPERTY).accept(this);
+		this.result.append("::"); //$NON-NLS-1$
+		visitList(node, TypeMethodReference.TYPE_ARGUMENTS_PROPERTY, Util.EMPTY_STRING, String.valueOf('<'), String.valueOf('>'));
+		node.getName().accept(this);
+		return false;
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeParameter)
 	 */