/*******************************************************************************
* Copyright (c) 2013, 2015 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
*
* 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;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
@SuppressWarnings("rawtypes")
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();
SimpleType simpleType = ast.newSimpleType(ast.newSimpleName("Integer"));
listRewrite = rewrite.getListRewrite(creationReference, CreationReference.TYPE_ARGUMENTS_PROPERTY);
listRewrite.insertLast(simpleType, 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);
simpleType = ast.newSimpleType(ast.newSimpleName("String"));
listRewrite.insertFirst(simpleType, 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 = 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();
SimpleType simpleType = ast.newSimpleType((ast.newSimpleName("String")));
rewrite.replace(expressionMethodReference.getExpression(), ast.newSimpleName("z"), null);
rewrite.getListRewrite(expressionMethodReference, ExpressionMethodReference.TYPE_ARGUMENTS_PROPERTY).insertFirst(simpleType, 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();
SimpleType simpleType = ast.newSimpleType((ast.newSimpleName("Integer")));
Type newType = ast.newSimpleType(ast.newSimpleName("W"));
rewrite.replace(typeMethodReference.getType(), newType, null);
rewrite.getListRewrite(typeMethodReference, TypeMethodReference.TYPE_ARGUMENTS_PROPERTY).insertFirst(simpleType, 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);
SimpleType simpleType = ast.newSimpleType(ast.newSimpleName("String"));
rewrite.getListRewrite(superMethodReference, SuperMethodReference.TYPE_ARGUMENTS_PROPERTY).insertFirst(simpleType, 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);
this.project1.setOption(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_8);
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());
}
}