Attachment #236294 for bug #394549

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 394549
Collapse All | Expand All

Added Link Here

(-)a/org.eclipse.jdt.ui.tests.refactoring/resources/ExtractClass/testGenericNested/in/GenericNested.java (+8 lines)
1	package p;
2
3	class GenericNested<T> {
4	C m;
5
6	class C {
7	}
8	}




package p;

class GenericNested<T> {
    public static class Extracted<T> {
		public GenericNested<T>.C m;
		public Extracted() {
		}
	}

	Extracted<T> parameterObject = new Extracted<T>();

	class C {
    }
}




 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Nikolay Metchev <nikolaymetchev@gmail.com> - [extract class] Extract class refactoring on a field in an inner non-static class yields compilation error - https://bugs.eclipse.org/394547
 *                                                - [extract class] Extract class on a field with inner non-static type in generic class yields compilation error - https://bugs.eclipse.org/394549
 *     Samrat Dhillon samrat.dhillon@gmail.com - [extract class] Extract class on a field with generic type yields compilation error  - https://bugs.eclipse.org/394548
 *******************************************************************************/
package org.eclipse.jdt.ui.tests.refactoring;

import java.io.IOException;
import java.util.HashMap;

		fDescriptor.setType(inner);
		fDescriptor.setClassName("Extracted");
		fDescriptor.setCreateTopLevel(false);
		runRefactoring(false);
	}
	
	// see bug 394549
	public void testGenericNested() throws Exception {
		IType outer= setupType();
		fDescriptor.setType(outer);
		fDescriptor.setClassName("Extracted");
		fDescriptor.setCreateTopLevel(false);
		runRefactoring(false);
	}
	
	// see bug 394548
	public void testTypeParameter() throws Exception {
		fDescriptor.setType(setupType());
		fDescriptor.setCreateTopLevel(false);
		fDescriptor.setFieldName("data");




 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Nikolay Metchev <nikolaymetchev@gmail.com> - [extract class] Extract class refactoring on a field in an inner non-static class yields compilation error - https://bugs.eclipse.org/394547
 *                                                - [extract class] Extract class on a field with inner non-static type in generic class yields compilation error - https://bugs.eclipse.org/394549
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.refactoring.structure;

import java.util.ArrayList;
import java.util.Arrays;

					}
				}
			}
			pm.worked(5);
			fChangeManager= new TextChangeManager();
			fParameterObjectFactory= initializeFactory();
			IType type= fDescriptor.getType();
			fBaseCURewrite= new CompilationUnitRewrite(type.getCompilationUnit());
			fParameterObjectFactory= initializeFactory();
			pm.worked(5);

			FieldDeclaration field= performFieldRewrite(type, fParameterObjectFactory, result);
			int flags= RefactoringDescriptor.STRUCTURAL_CHANGE | JavaRefactoringDescriptor.JAR_MIGRATION | JavaRefactoringDescriptor.JAR_REFACTORING | JavaRefactoringDescriptor.JAR_SOURCE_ATTACHMENT;
			if (!Modifier.isPrivate(field.getModifiers()))

		ITypeBinding binding= enclosingTypeDecl.resolveBinding();
		int modifiers= binding != null ? binding.getModifiers() : enclosingTypeDecl.getModifiers();
		return Modifier.isStatic(modifiers);
	}

	private ParameterObjectFactory initializeFactory() throws JavaModelException {
		ParameterObjectFactory pof= new ParameterObjectFactory();
		pof.setClassName(fDescriptor.getClassName());
		pof.setPackage(fDescriptor.getPackage());
		pof.setEnclosingType(fDescriptor.getType().getFullyQualifiedName('.'));
		pof.setCreateGetter(fDescriptor.isCreateGetterSetter());
		pof.setCreateSetter(fDescriptor.isCreateGetterSetter());
		TypeDeclaration typeDecl= ASTNodeSearchUtil.getTypeDeclarationNode(fDescriptor.getType(), fBaseCURewrite.getRoot());
		if (!fDescriptor.isCreateTopLevel()) {
			pof.setImportRewriteContext(pof.createParameterClassAwareContext(fDescriptor.isCreateTopLevel(), fBaseCURewrite, typeDecl.getStartPosition()));
		}
		List<ParameterInfo> variables= new ArrayList<ParameterInfo>();
		for (Iterator<FieldInfo> iterator= fVariables.values().iterator(); iterator.hasNext();) {
			FieldInfo info= iterator.next();
			boolean createField= isCreateField(info);
			info.pi.setCreateField(createField);

	private FieldInfo getFieldInfo(String identifier) {
		return fVariables.get(identifier);
	}

	private FieldDeclaration performFieldRewrite(IType type, ParameterObjectFactory pof, RefactoringStatus status) throws CoreException {
		fBaseCURewrite= new CompilationUnitRewrite(type.getCompilationUnit());
		SimpleName name= (SimpleName) NodeFinder.perform(fBaseCURewrite.getRoot(), type.getNameRange());
		TypeDeclaration typeNode= (TypeDeclaration) ASTNodes.getParent(name, ASTNode.TYPE_DECLARATION);
		ASTRewrite rewrite= fBaseCURewrite.getASTRewrite();
		int modifier= Modifier.PRIVATE;
		TextEditGroup removeFieldGroup= fBaseCURewrite.createGroupDescription(RefactoringCoreMessages.ExtractClassRefactoring_group_remove_field);

					ASTNode createMoveTarget= fBaseCURewrite.getASTRewrite().createMoveTarget(expression);
					if (expression instanceof ArrayInitializer) {
						ArrayInitializer ai= (ArrayInitializer) expression;
						ITypeBinding componentType= ai.resolveTypeBinding().getComponentType();
						ArrayCreation arrayCreation= ast.newArrayCreation();
						Type addImport= fBaseCURewrite.getImportRewrite().addImport(componentType, ast, fParameterObjectFactory.getImportRewriteContext());
						fBaseCURewrite.getImportRemover().registerAddedImports(addImport);
						arrayCreation.setType(ast.newArrayType(addImport));
						arrayCreation.setInitializer((ArrayInitializer) createMoveTarget);
						listRewrite.insertLast(arrayCreation, null);
					} else {

	}

	private void importNodeTypes(ASTNode node, final CompilationUnitRewrite cuRewrite) {
		ASTResolving.visitAllBindings(node, new TypeBindingVisitor() {
			public boolean visit(ITypeBinding nodeBinding) {
				fParameterObjectFactory.importBinding(nodeBinding, cuRewrite);
				return false;
			}
		});
	}





 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Samrat Dhillon samrat.dhillon@gmail.com https://bugs.eclipse.org/395558 , https://bugs.eclipse.org/395561 and https://bugs.eclipse.org/394548
 *     Nikolay Metchev <nikolaymetchev@gmail.com> - [extract class] Extract class on a field with inner non-static type in generic class yields compilation error - https://bugs.eclipse.org/394549
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.refactoring.structure;

import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.QualifiedType;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.SuperFieldAccess;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;

	private String fClassName;
	private boolean fCreateGetter;
	private boolean fCreateSetter;
	private String fEnclosingType;
	private String fPackage;

	private ImportRewriteContext fImportRewriteContext;
	private List<ParameterInfo> fVariables;

	public ParameterObjectFactory() {
		super();
	}

				if(oldTypeBinding != null && oldTypeBinding.isTypeVariable()){
					TypeParameter param= ast.newTypeParameter();
					param.setName(ast.newSimpleName(pi.getNewTypeName()));
					typeDeclaration.typeParameters().add(param);
				}
				Type declarationType= declaration.getType();
				if (declarationType.getNodeType() == ASTNode.QUALIFIED_TYPE) {
					Type qualifier= ((QualifiedType) declarationType).getQualifier();
					if (qualifier.isParameterizedType()) {
						for (Type type : (List<Type>) ((ParameterizedType) qualifier).typeArguments()) {
							TypeParameter typeParameter= ast.newTypeParameter();
							typeParameter.setName(ast.newSimpleName(((SimpleType) type).getName().getFullyQualifiedName()));
							typeDeclaration.typeParameters().add(typeParameter);
						}
					}
				}
			}
		}
		MethodDeclaration constructor= createConstructor(declaringType, cuRewrite, listener);
		listener.constructorCreated(cuRewrite, constructor);
		body.add(constructor);

		String[] suggestions= StubUtility.getVariableNameSuggestions(NamingConventions.VK_PARAMETER, project, strippedName, 0, usedParameter, true);
		return suggestions[0];
	}


	public Type importBinding(ITypeBinding typeBinding, CompilationUnitRewrite cuRewrite) {
		int declaredModifiers= typeBinding.getDeclaredModifiers();
		AST ast= cuRewrite.getAST();
		if (Modifier.isPrivate(declaredModifiers) || Modifier.isProtected(declaredModifiers)) {
			return ast.newSimpleType(ast.newSimpleName(typeBinding.getName()));
		}
		Type type= cuRewrite.getImportRewrite().addImport(typeBinding, cuRewrite.getAST(), fImportRewriteContext);
		cuRewrite.getImportRemover().registerAddedImports(type);
		if (typeBinding.isNested()) {
			ITypeBinding declaringClass= typeBinding.getDeclaringClass();
			if (Modifier.isStatic(typeBinding.getModifiers())) {
				declaringClass= declaringClass.getErasure();
			}
			Type newQualification= importBinding(declaringClass, cuRewrite);
			cuRewrite.getImportRemover().registerAddedImports(type);
			type= ast.newQualifiedType(newQualification, (SimpleName) ASTNode.copySubtree(ast, ((SimpleType) type).getName()));
		}
		return type;
	}

	private FieldDeclaration createField(ParameterInfo pi, CompilationUnitRewrite cuRewrite) throws CoreException {
		AST ast= cuRewrite.getAST();

		ImportRewrite importRewrite= cuRewrite.getImportRewrite();
		ContextSensitiveImportRewriteContext context= createParameterClassAwareContext(asTopLevelClass, cuRewrite, position);
		String addedImport= importRewrite.addImport(concatenateName, context);
		cuRewrite.getImportRemover().registerAddedImport(addedImport);
		AST ast= cuRewrite.getAST();
		SimpleType newSimpleType= ast.newSimpleType(ast.newName(addedImport));
		ParameterizedType parameterizedType= null;
		CompilationUnitRewrite dummyCuRewrite= new CompilationUnitRewrite(cuRewrite.getCu());
		for (Iterator<ParameterInfo> iter= fVariables.iterator(); iter.hasNext();) {
			ParameterInfo pi= iter.next();
			if (isValidField(pi)) {
				Type importBinding= importBinding(pi.getNewTypeBinding(), dummyCuRewrite);
				if (importBinding.getNodeType() == ASTNode.QUALIFIED_TYPE) {
					Type fieldQualifier= ((QualifiedType) importBinding).getQualifier();
					if (fieldQualifier.isParameterizedType()) {
						if (parameterizedType == null) {
							parameterizedType= ast.newParameterizedType(newSimpleType);
						}
						for (Type type : (List<Type>) ((ParameterizedType) fieldQualifier).typeArguments()) {
							parameterizedType.typeArguments().add(ASTNode.copySubtree(ast, type));
						}
					}
				}
			}
		}
		return parameterizedType == null ? newSimpleType : parameterizedType;
	}

	ContextSensitiveImportRewriteContext createParameterClassAwareContext(final boolean asTopLevelClass, final CompilationUnitRewrite cuRewrite, int position) {
		ContextSensitiveImportRewriteContext context= new ContextSensitiveImportRewriteContext(cuRewrite.getRoot(), position, cuRewrite.getImportRewrite()) {
			@Override


	public void setVariables(List<ParameterInfo> parameters) {
		fVariables= parameters;
	}

	public void setImportRewriteContext(ImportRewriteContext importRewriteContext) {
		fImportRewriteContext= importRewriteContext;
	}

	public ImportRewriteContext getImportRewriteContext() {
		return fImportRewriteContext;
	}

	/**
	 * Updates the position of the newly inserted parameterObject so that it is
	 * directly after the first checked parameter
	 *
	 * @param parameterObjectReference the inserted parameterObject

Return to bug 394549

Lines 6-16 Link Here

(-)a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/ExtractClassTests.java (-1 / +12 lines)
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Nikolay Metchev <nikolaymetchev@gmail.com> - [extract class] Extract class refactoring on a field in an inner non-static class yields compilation error - https://bugs.eclipse.org/394547	10	* Nikolay Metchev <nikolaymetchev@gmail.com> - [extract class] Extract class refactoring on a field in an inner non-static class yields compilation error - https://bugs.eclipse.org/394547
11	* Samrat Dhillon samrat.dhillon@gmail.com - [extract class] Extract class on a field with generic type yields compilation error - https://bugs.eclipse.org/bugs/show_bug.cgi?id=394548	11	* - [extract class] Extract class on a field with inner non-static type in generic class yields compilation error - https://bugs.eclipse.org/394549
		12	* Samrat Dhillon samrat.dhillon@gmail.com - [extract class] Extract class on a field with generic type yields compilation error - https://bugs.eclipse.org/394548
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.jdt.ui.tests.refactoring;	14	package org.eclipse.jdt.ui.tests.refactoring;
14		15
15	import java.io.IOException;	16	import java.io.IOException;
16	import java.util.HashMap;	17	import java.util.HashMap;
Lines 431-440 Link Here
431	fDescriptor.setType(inner);	432	fDescriptor.setType(inner);
432	fDescriptor.setClassName("Extracted");	433	fDescriptor.setClassName("Extracted");
433	fDescriptor.setCreateTopLevel(false);	434	fDescriptor.setCreateTopLevel(false);
434	runRefactoring(false);	435	runRefactoring(false);
435	}	436	}
		437
		438	// see bug 394549
		439	public void testGenericNested() throws Exception {
		440	IType outer= setupType();
		441	fDescriptor.setType(outer);
		442	fDescriptor.setClassName("Extracted");
		443	fDescriptor.setCreateTopLevel(false);
		444	runRefactoring(false);
		445	}
		446
436	// see bug 394548	447	// see bug 394548
437	public void testTypeParameter() throws Exception {	448	public void testTypeParameter() throws Exception {
438	fDescriptor.setType(setupType());	449	fDescriptor.setType(setupType());
439	fDescriptor.setCreateTopLevel(false);	450	fDescriptor.setCreateTopLevel(false);
440	fDescriptor.setFieldName("data");	451	fDescriptor.setFieldName("data");

Lines 5-15 Link Here

(-)a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ParameterObjectFactory.java (-4 / +58 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Samrat Dhillon samrat.dhillon@gmail.com https://bugs.eclipse.org/bugs/show_bug.cgi?id=395558 , https://bugs.eclipse.org/bugs/show_bug.cgi?id=395561 and https://bugs.eclipse.org/bugs/show_bug.cgi?id=394548	10	* Samrat Dhillon samrat.dhillon@gmail.com https://bugs.eclipse.org/395558 , https://bugs.eclipse.org/395561 and https://bugs.eclipse.org/394548
		11	* Nikolay Metchev <nikolaymetchev@gmail.com> - [extract class] Extract class on a field with inner non-static type in generic class yields compilation error - https://bugs.eclipse.org/394549
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.jdt.internal.corext.refactoring.structure;	13	package org.eclipse.jdt.internal.corext.refactoring.structure;
13		14
14	import java.util.ArrayList;	15	import java.util.ArrayList;
15	import java.util.Iterator;	16	import java.util.Iterator;
Lines 54-64 Link Here
54	import org.eclipse.jdt.core.dom.MethodDeclaration;	55	import org.eclipse.jdt.core.dom.MethodDeclaration;
55	import org.eclipse.jdt.core.dom.MethodInvocation;	56	import org.eclipse.jdt.core.dom.MethodInvocation;
56	import org.eclipse.jdt.core.dom.Modifier;	57	import org.eclipse.jdt.core.dom.Modifier;
57	import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;	58	import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
58	import org.eclipse.jdt.core.dom.Name;	59	import org.eclipse.jdt.core.dom.Name;
		60	import org.eclipse.jdt.core.dom.ParameterizedType;
		61	import org.eclipse.jdt.core.dom.QualifiedType;
59	import org.eclipse.jdt.core.dom.SimpleName;	62	import org.eclipse.jdt.core.dom.SimpleName;
		63	import org.eclipse.jdt.core.dom.SimpleType;
60	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;	64	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
61	import org.eclipse.jdt.core.dom.Statement;	65	import org.eclipse.jdt.core.dom.Statement;
62	import org.eclipse.jdt.core.dom.SuperFieldAccess;	66	import org.eclipse.jdt.core.dom.SuperFieldAccess;
63	import org.eclipse.jdt.core.dom.Type;	67	import org.eclipse.jdt.core.dom.Type;
64	import org.eclipse.jdt.core.dom.TypeDeclaration;	68	import org.eclipse.jdt.core.dom.TypeDeclaration;
Lines 90-99 Link Here
90	private String fClassName;	94	private String fClassName;
91	private boolean fCreateGetter;	95	private boolean fCreateGetter;
92	private boolean fCreateSetter;	96	private boolean fCreateSetter;
93	private String fEnclosingType;	97	private String fEnclosingType;
94	private String fPackage;	98	private String fPackage;
		99
		100	private ImportRewriteContext fImportRewriteContext;
95	private List<ParameterInfo> fVariables;	101	private List<ParameterInfo> fVariables;
96		102
97	public ParameterObjectFactory() {	103	public ParameterObjectFactory() {
98	super();	104	super();
99	}	105	}
Lines 198-207 Link Here
198	if(oldTypeBinding != null && oldTypeBinding.isTypeVariable()){	204	if(oldTypeBinding != null && oldTypeBinding.isTypeVariable()){
199	TypeParameter param= ast.newTypeParameter();	205	TypeParameter param= ast.newTypeParameter();
200	param.setName(ast.newSimpleName(pi.getNewTypeName()));	206	param.setName(ast.newSimpleName(pi.getNewTypeName()));
201	typeDeclaration.typeParameters().add(param);	207	typeDeclaration.typeParameters().add(param);
202	}	208	}
		209	Type declarationType= declaration.getType();
		210	if (declarationType.getNodeType() == ASTNode.QUALIFIED_TYPE) {
		211	Type qualifier= ((QualifiedType) declarationType).getQualifier();
		212	if (qualifier.isParameterizedType()) {
		213	for (Type type : (List<Type>) ((ParameterizedType) qualifier).typeArguments()) {
		214	TypeParameter typeParameter= ast.newTypeParameter();
		215	typeParameter.setName(ast.newSimpleName(((SimpleType) type).getName().getFullyQualifiedName()));
		216	typeDeclaration.typeParameters().add(typeParameter);
		217	}
		218	}
		219	}
203	}	220	}
204	}	221	}
205	MethodDeclaration constructor= createConstructor(declaringType, cuRewrite, listener);	222	MethodDeclaration constructor= createConstructor(declaringType, cuRewrite, listener);
206	listener.constructorCreated(cuRewrite, constructor);	223	listener.constructorCreated(cuRewrite, constructor);
207	body.add(constructor);	224	body.add(constructor);
Lines 296-313 Link Here
296	String[] suggestions= StubUtility.getVariableNameSuggestions(NamingConventions.VK_PARAMETER, project, strippedName, 0, usedParameter, true);	313	String[] suggestions= StubUtility.getVariableNameSuggestions(NamingConventions.VK_PARAMETER, project, strippedName, 0, usedParameter, true);
297	return suggestions[0];	314	return suggestions[0];
298	}	315	}
299		316
300		317
301	public static Type importBinding(ITypeBinding typeBinding, CompilationUnitRewrite cuRewrite) {	318	public Type importBinding(ITypeBinding typeBinding, CompilationUnitRewrite cuRewrite) {
302	int declaredModifiers= typeBinding.getDeclaredModifiers();	319	int declaredModifiers= typeBinding.getDeclaredModifiers();
303	AST ast= cuRewrite.getAST();	320	AST ast= cuRewrite.getAST();
304	if (Modifier.isPrivate(declaredModifiers) \|\| Modifier.isProtected(declaredModifiers)) {	321	if (Modifier.isPrivate(declaredModifiers) \|\| Modifier.isProtected(declaredModifiers)) {
305	return ast.newSimpleType(ast.newSimpleName(typeBinding.getName()));	322	return ast.newSimpleType(ast.newSimpleName(typeBinding.getName()));
306	}	323	}
307	Type type= cuRewrite.getImportRewrite().addImport(typeBinding, cuRewrite.getAST());	324	Type type= cuRewrite.getImportRewrite().addImport(typeBinding, cuRewrite.getAST(), fImportRewriteContext);
308	cuRewrite.getImportRemover().registerAddedImports(type);	325	cuRewrite.getImportRemover().registerAddedImports(type);
		326	if (typeBinding.isNested()) {
		327	ITypeBinding declaringClass= typeBinding.getDeclaringClass();
		328	if (Modifier.isStatic(typeBinding.getModifiers())) {
		329	declaringClass= declaringClass.getErasure();
		330	}
		331	Type newQualification= importBinding(declaringClass, cuRewrite);
		332	cuRewrite.getImportRemover().registerAddedImports(type);
		333	type= ast.newQualifiedType(newQualification, (SimpleName) ASTNode.copySubtree(ast, ((SimpleType) type).getName()));
		334	}
309	return type;	335	return type;
310	}	336	}
311		337
312	private FieldDeclaration createField(ParameterInfo pi, CompilationUnitRewrite cuRewrite) throws CoreException {	338	private FieldDeclaration createField(ParameterInfo pi, CompilationUnitRewrite cuRewrite) throws CoreException {
313	AST ast= cuRewrite.getAST();	339	AST ast= cuRewrite.getAST();
Lines 477-487 Link Here
477	ImportRewrite importRewrite= cuRewrite.getImportRewrite();	503	ImportRewrite importRewrite= cuRewrite.getImportRewrite();
478	ContextSensitiveImportRewriteContext context= createParameterClassAwareContext(asTopLevelClass, cuRewrite, position);	504	ContextSensitiveImportRewriteContext context= createParameterClassAwareContext(asTopLevelClass, cuRewrite, position);
479	String addedImport= importRewrite.addImport(concatenateName, context);	505	String addedImport= importRewrite.addImport(concatenateName, context);
480	cuRewrite.getImportRemover().registerAddedImport(addedImport);	506	cuRewrite.getImportRemover().registerAddedImport(addedImport);
481	AST ast= cuRewrite.getAST();	507	AST ast= cuRewrite.getAST();
482	return ast.newSimpleType(ast.newName(addedImport));	508	SimpleType newSimpleType= ast.newSimpleType(ast.newName(addedImport));
		509	ParameterizedType parameterizedType= null;
		510	CompilationUnitRewrite dummyCuRewrite= new CompilationUnitRewrite(cuRewrite.getCu());
		511	for (Iterator<ParameterInfo> iter= fVariables.iterator(); iter.hasNext();) {
		512	ParameterInfo pi= iter.next();
		513	if (isValidField(pi)) {
		514	Type importBinding= importBinding(pi.getNewTypeBinding(), dummyCuRewrite);
		515	if (importBinding.getNodeType() == ASTNode.QUALIFIED_TYPE) {
		516	Type fieldQualifier= ((QualifiedType) importBinding).getQualifier();
		517	if (fieldQualifier.isParameterizedType()) {
		518	if (parameterizedType == null) {
		519	parameterizedType= ast.newParameterizedType(newSimpleType);
		520	}
		521	for (Type type : (List<Type>) ((ParameterizedType) fieldQualifier).typeArguments()) {
		522	parameterizedType.typeArguments().add(ASTNode.copySubtree(ast, type));
		523	}
		524	}
		525	}
		526	}
		527	}
		528	return parameterizedType == null ? newSimpleType : parameterizedType;
483	}	529	}
484		530
485	ContextSensitiveImportRewriteContext createParameterClassAwareContext(final boolean asTopLevelClass, final CompilationUnitRewrite cuRewrite, int position) {	531	ContextSensitiveImportRewriteContext createParameterClassAwareContext(final boolean asTopLevelClass, final CompilationUnitRewrite cuRewrite, int position) {
486	ContextSensitiveImportRewriteContext context= new ContextSensitiveImportRewriteContext(cuRewrite.getRoot(), position, cuRewrite.getImportRewrite()) {	532	ContextSensitiveImportRewriteContext context= new ContextSensitiveImportRewriteContext(cuRewrite.getRoot(), position, cuRewrite.getImportRewrite()) {
487	@Override	533	@Override
Lines 598-607 Link Here
598		644
599	public void setVariables(List<ParameterInfo> parameters) {	645	public void setVariables(List<ParameterInfo> parameters) {
600	fVariables= parameters;	646	fVariables= parameters;
601	}	647	}
602		648
		649	public void setImportRewriteContext(ImportRewriteContext importRewriteContext) {
		650	fImportRewriteContext= importRewriteContext;
		651	}
		652
		653	public ImportRewriteContext getImportRewriteContext() {
		654	return fImportRewriteContext;
		655	}
		656
603	/**	657	/**
604	* Updates the position of the newly inserted parameterObject so that it is	658	* Updates the position of the newly inserted parameterObject so that it is
605	* directly after the first checked parameter	659	* directly after the first checked parameter
606	*	660	*
607	* @param parameterObjectReference the inserted parameterObject	661	* @param parameterObjectReference the inserted parameterObject