Attachment #36998 for bug #112999

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

Lines 40-48 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/AbstractFix.java (-5 / +13 lines)
40		40
41	public static abstract class AbstractFixRewriteOperation implements IFixRewriteOperation {	41	public static abstract class AbstractFixRewriteOperation implements IFixRewriteOperation {
42		42
43	protected Type importType(final ITypeBinding toImport, final ASTNode accessor, ImportRewrite imports, final CompilationUnit compilationUnit) {	43	protected Type importType(final ITypeBinding toImport, final ASTNode accessor, CompilationUnitRewrite cuRewrite, final CompilationUnit compilationUnit) {
		44	ImportRewrite imports= cuRewrite.getImportRewrite();
44	ImportRewriteContext importContext= new ContextSensitiveImportRewriteContext(compilationUnit, accessor.getStartPosition(), imports);	45	ImportRewriteContext importContext= new ContextSensitiveImportRewriteContext(compilationUnit, accessor.getStartPosition(), imports);
45	return imports.addImport(toImport, compilationUnit.getAST(), importContext);	46	Type result= imports.addImport(toImport, compilationUnit.getAST(), importContext);
		47	cuRewrite.getImportRemover().registerAddedImport(toImport.getQualifiedName());
		48	return result;
46	}	49	}
47		50
48	protected TextEditGroup createTextEditGroup(String label) {	51	protected TextEditGroup createTextEditGroup(String label) {
Lines 80-94 Link Here
80	return fCompilationUnit;	83	return fCompilationUnit;
81	}	84	}
82		85
		86	/**
		87	* {@inheritDoc}
		88	*/
		89	public TextChange createChange() throws CoreException {
		90	return createChange(new CompilationUnitRewrite(fCompilationUnit, fUnit));
		91	}
		92
83	/* (non-Javadoc)	93	/* (non-Javadoc)
84	* @see org.eclipse.jdt.internal.corext.fix.IFix#createChange()	94	* @see org.eclipse.jdt.internal.corext.fix.IFix#createChange()
85	*/	95	*/
86	public TextChange createChange() throws CoreException {	96	public TextChange createChange(CompilationUnitRewrite cuRewrite) throws CoreException {
87	if (fFixRewrites == null \|\| fFixRewrites.length == 0)	97	if (fFixRewrites == null \|\| fFixRewrites.length == 0)
88	return null;	98	return null;
89		99
90	CompilationUnitRewrite cuRewrite= new CompilationUnitRewrite(getCompilationUnit(), fUnit);
91
92	List/<TextEditGroup>/ groups= new ArrayList();	100	List/<TextEditGroup>/ groups= new ArrayList();
93		101
94	for (int i= 0; i < fFixRewrites.length; i++) {	102	for (int i= 0; i < fFixRewrites.length; i++) {

Lines 19-37 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/VariableDeclarationFix.java (-10 / +211 lines)
19		19
20	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
21		21
		22	import org.eclipse.jdt.core.JavaModelException;
		23	import org.eclipse.jdt.core.dom.AST;
22	import org.eclipse.jdt.core.dom.ASTNode;	24	import org.eclipse.jdt.core.dom.ASTNode;
		25	import org.eclipse.jdt.core.dom.ArrayType;
23	import org.eclipse.jdt.core.dom.CompilationUnit;	26	import org.eclipse.jdt.core.dom.CompilationUnit;
24	import org.eclipse.jdt.core.dom.FieldDeclaration;	27	import org.eclipse.jdt.core.dom.FieldDeclaration;
25	import org.eclipse.jdt.core.dom.IBinding;	28	import org.eclipse.jdt.core.dom.IBinding;
		29	import org.eclipse.jdt.core.dom.ITypeBinding;
26	import org.eclipse.jdt.core.dom.IVariableBinding;	30	import org.eclipse.jdt.core.dom.IVariableBinding;
27	import org.eclipse.jdt.core.dom.MethodDeclaration;	31	import org.eclipse.jdt.core.dom.MethodDeclaration;
28	import org.eclipse.jdt.core.dom.Modifier;	32	import org.eclipse.jdt.core.dom.Modifier;
		33	import org.eclipse.jdt.core.dom.Name;
		34	import org.eclipse.jdt.core.dom.QualifiedName;
29	import org.eclipse.jdt.core.dom.SimpleName;	35	import org.eclipse.jdt.core.dom.SimpleName;
		36	import org.eclipse.jdt.core.dom.SimpleType;
30	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;	37	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
		38	import org.eclipse.jdt.core.dom.Type;
31	import org.eclipse.jdt.core.dom.VariableDeclarationExpression;	39	import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
32	import org.eclipse.jdt.core.dom.VariableDeclarationFragment;	40	import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
33	import org.eclipse.jdt.core.dom.VariableDeclarationStatement;	41	import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
34	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;	42	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
		43	import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
35		44
36	import org.eclipse.jdt.internal.corext.dom.ASTNodes;	45	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
37	import org.eclipse.jdt.internal.corext.dom.GenericVisitor;	46	import org.eclipse.jdt.internal.corext.dom.GenericVisitor;
Lines 42-48 Link Here
42	import org.eclipse.jdt.internal.ui.text.correction.ASTResolving;	51	import org.eclipse.jdt.internal.ui.text.correction.ASTResolving;
43		52
44	public class VariableDeclarationFix extends AbstractFix {	53	public class VariableDeclarationFix extends AbstractFix {
45		54
46	private static class WrittenNamesFinder extends GenericVisitor {	55	private static class WrittenNamesFinder extends GenericVisitor {
47		56
48	private final HashSet fResult;	57	private final HashSet fResult;
Lines 83-89 Link Here
83		92
84	public VariableDeclarationFinder(boolean addFinalFields,	93	public VariableDeclarationFinder(boolean addFinalFields,
85	boolean addFinalParameters,	94	boolean addFinalParameters,
86	boolean addFinalLocals,	95	boolean addFinalLocals,
87	final CompilationUnit compilationUnit, final List result, final HashSet writtenVariables) {	96	final CompilationUnit compilationUnit, final List result, final HashSet writtenVariables) {
88		97
89	super();	98	super();
Lines 244-249 Link Here
244	}	253	}
245	}	254	}
246		255
		256	private static class QualifierFinder extends GenericVisitor {
		257	private final boolean fRemoveQualifiedNames;
		258	private final List fResult;
		259	private final ImportRewrite fImportRewrite;
		260	private final CompilationUnit fCompilationUnit;
		261	private final boolean fAddQualifiedNames;
		262
		263	public QualifierFinder(final boolean removeQualifiedNames, boolean addQualifiedNames, final List result, ImportRewrite importRewrite, CompilationUnit compilationUnit) throws JavaModelException {
		264	super();
		265	fRemoveQualifiedNames= removeQualifiedNames;
		266	fAddQualifiedNames= addQualifiedNames;
		267	fResult= result;
		268	fImportRewrite= importRewrite;
		269	fCompilationUnit= compilationUnit;
		270	}
		271
		272	/**
		273	* {@inheritDoc}
		274	*/
		275	public boolean visit(QualifiedName node) {
		276	if (fRemoveQualifiedNames) {
		277	Type type= null;
		278	if (node.getParent() instanceof ArrayType) {
		279	type= (Type)node.getParent();
		280	} else if (node.getParent() instanceof SimpleType) {
		281	type= (Type)node.getParent();
		282	}
		283	if (type == null)
		284	return false;
		285
		286	ITypeBinding binding= type.resolveBinding();
		287	if (binding == null)
		288	return false;
		289
		290	String name= fImportRewrite.addImport(binding);
		291	if (name.indexOf('.') != -1)
		292	return false;
		293
		294	fResult.add(new ReplaceQualifiedNameByImport(node, type, fCompilationUnit));
		295	}
		296
		297	return false;
		298	}
		299
		300	/**
		301	* {@inheritDoc}
		302	*/
		303	public boolean visit(SimpleName node) {
		304	if (fAddQualifiedNames) {
		305	ASTNode parent= node.getParent();
		306	if (!(parent instanceof Type))
		307	return false;
		308
		309	Type type= (Type)parent;
		310	ITypeBinding binding= type.resolveBinding();
		311	if (binding == null)
		312	return false;
		313
		314	String qualifiedName= binding.getQualifiedName();
		315	if (qualifiedName == null \|\| qualifiedName.length() == 0)
		316	return false;
		317
		318	fResult.add(new FullyQualifyTypeOperation(type, fCompilationUnit));
		319	return false;
320	}
321	return super.visit(node);
322	}
323	}
324
325	private static class ReplaceQualifiedNameByImport extends AbstractFixRewriteOperation {
326
327	private final Type fType;
328	private final QualifiedName fName;
329	private final CompilationUnit fCompilationUnit;
330
331	public ReplaceQualifiedNameByImport(QualifiedName name, Type type, CompilationUnit compilationUnit) {
332	fName= name;
333	fType= type;
334	fCompilationUnit= compilationUnit;
335	}
336
337	/**
338	* {@inheritDoc}
339	*/
340	public void rewriteAST(CompilationUnitRewrite cuRewrite, List textEditGroups) throws CoreException {
341	Type type= importType(fType.resolveBinding(), fName, cuRewrite, fCompilationUnit);
342	Name tName= getTypeName(type);
343	if (!(tName instanceof SimpleName))
344	return;
345
346	ASTNode move= cuRewrite.getASTRewrite().createMoveTarget(fName.getName());
347	TextEditGroup group= createTextEditGroup("Unqualify type");
348	cuRewrite.getASTRewrite().replace(fName, move, group);
349	cuRewrite.getImportRemover().registerAddedImport(fName.getFullyQualifiedName());
350	cuRewrite.getImportRemover().registerRemovedNode(fName);
351	}
352	}
353
354	private static class FullyQualifyTypeOperation extends AbstractFixRewriteOperation {
355
356	private final Type fType;
357
358	public FullyQualifyTypeOperation(Type type, CompilationUnit compilationUnit) {
359	fType= type;
360	}
361
362	/**
363	* {@inheritDoc}
364	*/
365	public void rewriteAST(CompilationUnitRewrite cuRewrite, List textEditGroups) throws CoreException {
366	AST ast= cuRewrite.getAST();
367	ASTRewrite rewrite= cuRewrite.getASTRewrite();
368
369	SimpleName oldName= (SimpleName)getTypeName(fType);
370	SimpleName move= (SimpleName)rewrite.createMoveTarget(oldName);
371	String qualifiedName= fType.resolveBinding().getQualifiedName();
372	qualifiedName= removeSuffix(qualifiedName, oldName.getFullyQualifiedName());
373	Name qualifier= ast.newName(qualifiedName);
374	QualifiedName newName= ast.newQualifiedName(qualifier, move);
375	TextEditGroup group= createTextEditGroup("Fully qualify type");
376	rewrite.replace(oldName, newName, group);
377
378	cuRewrite.getImportRemover().registerRemovedNode(fType);
379	}
380
381	private String removeSuffix(String string, String suffix) {
382	int idx= string.lastIndexOf(suffix);
383	if (idx == -1)
384	return string;
385
386	return string.substring(0, idx-1);
387	}
388
389	}
390
247	public static IFix createChangeModifierToFinalFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {	391	public static IFix createChangeModifierToFinalFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
248	HashSet writtenNames= new HashSet();	392	HashSet writtenNames= new HashSet();
249	WrittenNamesFinder finder= new WrittenNamesFinder(writtenNames);	393	WrittenNamesFinder finder= new WrittenNamesFinder(writtenNames);
Lines 270-287 Link Here
270	return new VariableDeclarationFix(label, compilationUnit, result);	414	return new VariableDeclarationFix(label, compilationUnit, result);
271	}	415	}
272		416
273	public static IFix createCleanUp(CompilationUnit compilationUnit,	417	public static IFix createReplaceQualifierByImportFix(CompilationUnit compilationUnit, ASTNode[] selectedNodes) throws JavaModelException {
274	boolean addFinalFields, boolean addFinalParameters, boolean addFinalLocals) {	418	List ops= new ArrayList();
		419	QualifierFinder visitor= new QualifierFinder(true, false, ops, ImportRewrite.create(compilationUnit, true), compilationUnit);
		420	for (int i= 0; i < selectedNodes.length; i++) {
		421	ASTNode selectedNode= selectedNodes[i];
		422	while (selectedNode.getParent() instanceof QualifiedName)
		423	selectedNode= selectedNode.getParent();
		424
		425	selectedNode.accept(visitor);
		426	}
		427	if (ops.size() == 0)
		428	return null;
275		429
276	if (!addFinalFields && !addFinalParameters && !addFinalLocals)	430	IFixRewriteOperation[] result= (IFixRewriteOperation[])ops.toArray(new IFixRewriteOperation[ops.size()]);
		431	String label= "Replace qualifier with import";
		432	return new VariableDeclarationFix(label, compilationUnit, result);
		433	}
		434
		435	public static IFix createFullyQualifieTypeNameFix(CompilationUnit compilationUnit, ASTNode[] selectedNodes) throws JavaModelException {
		436	List ops= new ArrayList();
		437	QualifierFinder visitor= new QualifierFinder(false, true, ops, ImportRewrite.create(compilationUnit, true), compilationUnit);
		438	for (int i= 0; i < selectedNodes.length; i++) {
		439	ASTNode selectedNode= selectedNodes[i];
		440
		441	selectedNode.accept(visitor);
		442	}
		443	if (ops.size() == 0)
277	return null;	444	return null;
278		445
279	HashSet writtenNames= new HashSet();	446	IFixRewriteOperation[] result= (IFixRewriteOperation[])ops.toArray(new IFixRewriteOperation[ops.size()]);
280	WrittenNamesFinder finder= new WrittenNamesFinder(writtenNames);	447	String label= "Fully qualify type name";
281	compilationUnit.accept(finder);	448	return new VariableDeclarationFix(label, compilationUnit, result);
		449	}
		450
		451	public static IFix createCleanUp(CompilationUnit compilationUnit,
		452	boolean addFinalFields, boolean addFinalParameters, boolean addFinalLocals,
		453	boolean replaceQualifierWithImport, boolean qualifyNames) throws JavaModelException {
		454
		455	if (!addFinalFields && !addFinalParameters && !addFinalLocals && !replaceQualifierWithImport && !qualifyNames)
		456	return null;
		457
282	List operations= new ArrayList();	458	List operations= new ArrayList();
283	VariableDeclarationFinder visitor= new VariableDeclarationFinder(addFinalFields, addFinalParameters, addFinalLocals, compilationUnit, operations, writtenNames);	459
284	compilationUnit.accept(visitor);	460	if (addFinalFields \|\| addFinalParameters \|\| addFinalLocals) {
		461	HashSet writtenNames= new HashSet();
		462	WrittenNamesFinder finder= new WrittenNamesFinder(writtenNames);
		463	compilationUnit.accept(finder);
		464	VariableDeclarationFinder visitor= new VariableDeclarationFinder(addFinalFields, addFinalParameters, addFinalLocals, compilationUnit, operations, writtenNames);
		465	compilationUnit.accept(visitor);
		466	}
		467	if (replaceQualifierWithImport \|\| qualifyNames) {
		468	QualifierFinder visitor= new QualifierFinder(replaceQualifierWithImport, qualifyNames, operations, ImportRewrite.create(compilationUnit, true), compilationUnit);
		469	compilationUnit.accept(visitor);
		470	}
285		471
286	if (operations.isEmpty())	472	if (operations.isEmpty())
287	return null;	473	return null;
Lines 361-366 Link Here
361	}	547	}
362	return false;	548	return false;
363	}	549	}
		550
		551	private static Name getTypeName(Type type) {
		552	final Name[] result= new Name[1];
		553	type.accept(new GenericVisitor() {
		554	public boolean visit(QualifiedName node) {
		555	result[0]= node;
		556	return false;
		557	}
		558	public boolean visit(SimpleName node) {
		559	result[0]= node;
		560	return false;
		561	}
		562	});
		563	return result[0];
		564	}
364		565
365	protected VariableDeclarationFix(String name, CompilationUnit compilationUnit, IFixRewriteOperation[] fixRewriteOperations) {	566	protected VariableDeclarationFix(String name, CompilationUnit compilationUnit, IFixRewriteOperation[] fixRewriteOperations) {
366	super(name, compilationUnit, fixRewriteOperations);	567	super(name, compilationUnit, fixRewriteOperations);




import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTRequestor;
import org.eclipse.jdt.core.dom.CompilationUnit;

import org.eclipse.jdt.internal.corext.refactoring.changes.DynamicValidationStateChange;
import org.eclipse.jdt.internal.corext.refactoring.changes.TextChangeCompatibility;
import org.eclipse.jdt.internal.corext.refactoring.composite.MultiStateCompilationUnitChange;
import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;
import org.eclipse.jdt.internal.corext.util.Messages;


		}
		
		private ParseListElement calculateSolution(Hashtable solutions, CompilationUnit ast, ICleanUp[] cleanUps) {
			CompilationUnitRewrite cuRewrite= new CompilationUnitRewrite((ICompilationUnit)ast.getJavaElement(), ast);
			TextChange solution= null;
			ParseListElement result= null;
			for (int i= 0; i < cleanUps.length; i++) {

				try {
					IFix fix= cleanUp.createFix(ast);
					if (fix != null) {
						CompilationUnitRewrite curr= new CompilationUnitRewrite((ICompilationUnit)ast.getJavaElement(), ast);
						ASTNode[] removedNodes= cuRewrite.getImportRemover().getRemovedNodes();
						for (int j= 0; j < removedNodes.length; j++) {
							curr.getImportRemover().registerRemovedNode(removedNodes[j]);
						}
						String[] addedImports= cuRewrite.getImportRewrite().getAddedImports();
						for (int j= 0; j < addedImports.length; j++) {
							curr.getImportRewrite().addImport(addedImports[j]);
							curr.getImportRemover().registerAddedImport(addedImports[j]);
						}
						TextChange current= fix.createChange(curr);
						if (current instanceof TextFileChange && fLeaveFilesDirty)
							((TextFileChange)current).setSaveMode(TextFileChange.LEAVE_DIRTY);
						

							} else {
								mergeTextChanges(current, solution);
								solution= current;
								cuRewrite= curr;
							}
						} else {
							solution= current;
							cuRewrite= curr;
						}
					}
				} catch (CoreException e) {





import org.eclipse.ltk.core.refactoring.TextChange;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.rewrite.ITrackedNodePosition;


	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.corext.fix.IFix#createChange()
	 */
	public TextChange createChange(CompilationUnitRewrite cuRewrite) throws CoreException {
		if (fFixRewrites == null || fFixRewrites.length == 0)
			return null;

		CompilationUnitRewrite cuRewrite= new CompilationUnitRewrite((ICompilationUnit)fCompilationUnit.getJavaElement(), fCompilationUnit);
	
		List/*<TextEditGroup>*/ groups= new ArrayList();


Lines 35-40 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/StringFix.java (+8 lines)
35	import org.eclipse.jdt.internal.corext.refactoring.changes.CompilationUnitChange;	35	import org.eclipse.jdt.internal.corext.refactoring.changes.CompilationUnitChange;
36	import org.eclipse.jdt.internal.corext.refactoring.changes.TextChangeCompatibility;	36	import org.eclipse.jdt.internal.corext.refactoring.changes.TextChangeCompatibility;
37	import org.eclipse.jdt.internal.corext.refactoring.nls.NLSUtil;	37	import org.eclipse.jdt.internal.corext.refactoring.nls.NLSUtil;
		38	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
38		39
39	import org.eclipse.jdt.ui.text.java.IProblemLocation;	40	import org.eclipse.jdt.ui.text.java.IProblemLocation;
40		41
Lines 191-196 Link Here
191	fCompilationUnit= (ICompilationUnit)compilationUnit.getJavaElement();	192	fCompilationUnit= (ICompilationUnit)compilationUnit.getJavaElement();
192	fEditGroups= groups;	193	fEditGroups= groups;
193	}	194	}
		195
		196	/**
		197	* {@inheritDoc}
		198	*/
		199	public TextChange createChange(CompilationUnitRewrite cuRewrite) throws CoreException {
		200	return createChange();
		201	}
194		202
195	/* (non-Javadoc)	203	/* (non-Javadoc)
196	* @see org.eclipse.jdt.internal.corext.fix.AbstractFix#createChange()	204	* @see org.eclipse.jdt.internal.corext.fix.AbstractFix#createChange()

Lines 16-21 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/IFix.java (+11 lines)
16		16
17	import org.eclipse.jdt.core.ICompilationUnit;	17	import org.eclipse.jdt.core.ICompilationUnit;
18		18
		19	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
		20
19	/**	21	/**
20	* An <code>IFix</code> can calculate a <code>TextChange</code>	22	* An <code>IFix</code> can calculate a <code>TextChange</code>
21	* which applied to a <code>ICompilationUnit</code> will fix	23	* which applied to a <code>ICompilationUnit</code> will fix
Lines 43-48 Link Here
43	public abstract TextChange createChange() throws CoreException;	45	public abstract TextChange createChange() throws CoreException;
44		46
45	/**	47	/**
		48	* A <code>TextChange</code> which applied to <code>getCompilationUnit</code>
		49	* will fix a problem.
		50	*
		51	* @return The change or null if no fix possible
		52	* @throws CoreException
		53	*/
		54	public abstract TextChange createChange(CompilationUnitRewrite cuRewrite) throws CoreException;
		55
		56	/**
46	* The <code>ICompilationUnit</code> on which <code>createChange</code> should	57	* The <code>ICompilationUnit</code> on which <code>createChange</code> should
47	* be applied to fix a problem.	58	* be applied to fix a problem.
48	*	59	*

Lines 433-441 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/ConvertForLoopOperation.java (-5 / +7 lines)
433	return fIndexBinding;	433	return fIndexBinding;
434	}	434	}
435		435
436	private ITrackedNodePosition doConvert(ASTRewrite rewrite, ImportRewrite importRewrite, TextEditGroup group) throws CoreException {	436	private ITrackedNodePosition doConvert(CompilationUnitRewrite cuRewrite, TextEditGroup group) throws CoreException {
		437	ASTRewrite rewrite= cuRewrite.getASTRewrite();
		438	ImportRewrite importRewrite= cuRewrite.getImportRewrite();
437	doInferCollection();	439	doInferCollection();
438	doInferElement(importRewrite);	440	doInferElement(cuRewrite);
439	doFindAndReplaceInBody(rewrite, group);	441	doFindAndReplaceInBody(rewrite, group);
440		442
441	AST ast= fOldForStatement.getAST();	443	AST ast= fOldForStatement.getAST();
Lines 591-597 Link Here
591	}	593	}
592	}	594	}
593		595
594	private void doInferElement(ImportRewrite importRewrite) throws CoreException {	596	private void doInferElement(CompilationUnitRewrite cuRewrite) throws CoreException {
595	if (fCollectionName == null) {	597	if (fCollectionName == null) {
596	createDefaultParameter();	598	createDefaultParameter();
597	} else {	599	} else {
Lines 601-607 Link Here
601	SimpleName name= fAst.newSimpleName(fParameterName);	603	SimpleName name= fAst.newSimpleName(fParameterName);
602	fParameterDeclaration.setName(name);	604	fParameterDeclaration.setName(name);
603		605
604	Type theType= importType(elementType, fOldForStatement, importRewrite, fRoot);	606	Type theType= importType(elementType, fOldForStatement, cuRewrite, fRoot);
605	if (fOldCollectionTypeBinding.getDimensions() != 1) {	607	if (fOldCollectionTypeBinding.getDimensions() != 1) {
606	theType= fAst.newArrayType(theType, fOldCollectionTypeBinding.getDimensions() - 1);	608	theType= fAst.newArrayType(theType, fOldCollectionTypeBinding.getDimensions() - 1);
607	}	609	}
Lines 772-778 Link Here
772	TextEditGroup group= createTextEditGroup(FixMessages.Java50Fix_ConvertToEnhancedForLoop_description);	774	TextEditGroup group= createTextEditGroup(FixMessages.Java50Fix_ConvertToEnhancedForLoop_description);
773	textEditGroups.add(group);	775	textEditGroups.add(group);
774	clearPositionGroups();	776	clearPositionGroups();
775	ITrackedNodePosition endPosition= doConvert(cuRewrite.getASTRewrite(), cuRewrite.getImportRewrite(), group);	777	ITrackedNodePosition endPosition= doConvert(cuRewrite, group);
776	positionGroups.addAll(getAllPositionGroups());	778	positionGroups.addAll(getAllPositionGroups());
777	return endPosition;	779	return endPosition;
778	}	780	}

Lines 199-206 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/ConvertIterableLoopOperation.java (-4 / +7 lines)
199	return fRoot.getAST().resolveWellKnownType("java.lang.Object"); //$NON-NLS-1$	199	return fRoot.getAST().resolveWellKnownType("java.lang.Object"); //$NON-NLS-1$
200	}	200	}
201		201
202	private ITrackedNodePosition rewriteAST(final AST ast, final ASTRewrite astRewrite, final ImportRewrite importRewrite, final TextEditGroup group) throws CoreException {	202	private ITrackedNodePosition rewriteAST(CompilationUnitRewrite cuRewrite, final TextEditGroup group) throws CoreException {
203	final ImportRemover remover= new ImportRemover(fCompilationUnit.getJavaProject(), (CompilationUnit) fStatement.getRoot());	203	final AST ast= cuRewrite.getAST();
		204	final ASTRewrite astRewrite= cuRewrite.getASTRewrite();
		205	final ImportRewrite importRewrite= cuRewrite.getImportRewrite();
		206	final ImportRemover remover= cuRewrite.getImportRemover();
204		207
205	final EnhancedForStatement statement= ast.newEnhancedForStatement();	208	final EnhancedForStatement statement= ast.newEnhancedForStatement();
206	final List names= computeElementNames();	209	final List names= computeElementNames();
Lines 276-282 Link Here
276	declaration.setName(simple);	279	declaration.setName(simple);
277	final ITypeBinding iterable= getIterableType(fIterator.getType());	280	final ITypeBinding iterable= getIterableType(fIterator.getType());
278	final ImportRewrite imports= importRewrite;	281	final ImportRewrite imports= importRewrite;
279	declaration.setType(importType(iterable, fStatement, importRewrite, fRoot));	282	declaration.setType(importType(iterable, fStatement, cuRewrite, fRoot));
280	remover.registerAddedImport(iterable.getQualifiedName());	283	remover.registerAddedImport(iterable.getQualifiedName());
281	statement.setParameter(declaration);	284	statement.setParameter(declaration);
282	statement.setExpression(getExpression(astRewrite));	285	statement.setExpression(getExpression(astRewrite));
Lines 500-506 Link Here
500	TextEditGroup group= createTextEditGroup(FixMessages.Java50Fix_ConvertToEnhancedForLoop_description);	503	TextEditGroup group= createTextEditGroup(FixMessages.Java50Fix_ConvertToEnhancedForLoop_description);
501	textEditGroups.add(group);	504	textEditGroups.add(group);
502	clearPositionGroups();	505	clearPositionGroups();
503	ITrackedNodePosition endPosition= rewriteAST(cuRewrite.getRoot().getAST(), cuRewrite.getASTRewrite(), cuRewrite.getImportRewrite(), group);	506	ITrackedNodePosition endPosition= rewriteAST(cuRewrite, group);
504	positionGroups.addAll(getAllPositionGroups());	507	positionGroups.addAll(getAllPositionGroups());
505	return endPosition;	508	return endPosition;
506	}	509	}

Lines 29-34 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java (-1 / +61 lines)
29		29
30	import org.eclipse.jdt.core.ICompilationUnit;	30	import org.eclipse.jdt.core.ICompilationUnit;
31	import org.eclipse.jdt.core.IJavaProject;	31	import org.eclipse.jdt.core.IJavaProject;
		32	import org.eclipse.jdt.core.JavaModelException;
32	import org.eclipse.jdt.core.compiler.IProblem;	33	import org.eclipse.jdt.core.compiler.IProblem;
33	import org.eclipse.jdt.core.dom.AST;	34	import org.eclipse.jdt.core.dom.AST;
34	import org.eclipse.jdt.core.dom.ASTNode;	35	import org.eclipse.jdt.core.dom.ASTNode;
Lines 61-66 Link Here
61	import org.eclipse.jdt.core.dom.Name;	62	import org.eclipse.jdt.core.dom.Name;
62	import org.eclipse.jdt.core.dom.ParenthesizedExpression;	63	import org.eclipse.jdt.core.dom.ParenthesizedExpression;
63	import org.eclipse.jdt.core.dom.PrimitiveType;	64	import org.eclipse.jdt.core.dom.PrimitiveType;
		65	import org.eclipse.jdt.core.dom.QualifiedName;
64	import org.eclipse.jdt.core.dom.SimpleName;	66	import org.eclipse.jdt.core.dom.SimpleName;
65	import org.eclipse.jdt.core.dom.SimpleType;	67	import org.eclipse.jdt.core.dom.SimpleType;
66	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;	68	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
Lines 142-148 Link Here
142	\|\| getSurroundWithRunnableProposal(context, coveringNode, null)	144	\|\| getSurroundWithRunnableProposal(context, coveringNode, null)
143	\|\| getRemoveBlockProposals(context, coveringNode, null)	145	\|\| getRemoveBlockProposals(context, coveringNode, null)
144	\|\| getFixDeprecationProposals(context, coveringNode, null)	146	\|\| getFixDeprecationProposals(context, coveringNode, null)
145	\|\| getMakeVariableDeclarationFinalProposals(context, coveringNode, null);	147	\|\| getMakeVariableDeclarationFinalProposals(context, coveringNode, null)
		148	\|\| getReplaceQualifierByImportProposal(context, coveringNode, null)
		149	\|\| getFullyQualifieTypeNameProposal(context, coveringNode, null);
146	}	150	}
147	return false;	151	return false;
148	}	152	}
Lines 176-181 Link Here
176	getRemoveBlockProposals(context, coveringNode, resultingCollections);	180	getRemoveBlockProposals(context, coveringNode, resultingCollections);
177	getFixDeprecationProposals(context, coveringNode, resultingCollections);	181	getFixDeprecationProposals(context, coveringNode, resultingCollections);
178	getMakeVariableDeclarationFinalProposals(context, coveringNode, resultingCollections);	182	getMakeVariableDeclarationFinalProposals(context, coveringNode, resultingCollections);
		183	getReplaceQualifierByImportProposal(context, coveringNode, resultingCollections);
		184	getFullyQualifieTypeNameProposal(context, coveringNode, resultingCollections);
179	}	185	}
180	return (IJavaCompletionProposal[]) resultingCollections.toArray(new IJavaCompletionProposal[resultingCollections.size()]);	186	return (IJavaCompletionProposal[]) resultingCollections.toArray(new IJavaCompletionProposal[resultingCollections.size()]);
181	}	187	}
Lines 1302-1305 Link Here
1302	resultingCollections.add(proposal);	1308	resultingCollections.add(proposal);
1303	return true;	1309	return true;
1304	}	1310	}
		1311
		1312	private boolean getReplaceQualifierByImportProposal(IInvocationContext context, ASTNode node, ArrayList resultingCollections) throws JavaModelException {
		1313	SelectionAnalyzer analyzer= new SelectionAnalyzer(Selection.createFromStartLength(context.getSelectionOffset(), context.getSelectionLength()), false);
		1314	context.getASTRoot().accept(analyzer);
		1315	ASTNode[] selectedNodes= analyzer.getSelectedNodes();
		1316	if (selectedNodes.length == 0) {
		1317	if (node == null)
		1318	return false;
		1319
		1320	ASTNode parent= node.getParent();
		1321	if (!(parent instanceof QualifiedName))
		1322	return false;
		1323
		1324	selectedNodes= new ASTNode[] {parent};
		1325	}
		1326
		1327	IFix fix= VariableDeclarationFix.createReplaceQualifierByImportFix(context.getASTRoot(), selectedNodes);
		1328	if (fix == null)
		1329	return false;
		1330
		1331	if (resultingCollections == null)
		1332	return true;
		1333
		1334	Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
		1335	VariableDeclarationCleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		1336	FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 3, image, context);
		1337	resultingCollections.add(proposal);
		1338	return true;
		1339	}
		1340
		1341	private boolean getFullyQualifieTypeNameProposal(IInvocationContext context, ASTNode node, ArrayList resultingCollections) throws JavaModelException {
		1342	SelectionAnalyzer analyzer= new SelectionAnalyzer(Selection.createFromStartLength(context.getSelectionOffset(), context.getSelectionLength()), false);
		1343	context.getASTRoot().accept(analyzer);
		1344	ASTNode[] selectedNodes= analyzer.getSelectedNodes();
		1345	if (selectedNodes.length == 0) {
		1346	if (node == null)
		1347	return false;
		1348
		1349	selectedNodes= new ASTNode[] {node};
		1350	}
		1351
		1352	IFix fix= VariableDeclarationFix.createFullyQualifieTypeNameFix(context.getASTRoot(), selectedNodes);
		1353	if (fix == null)
		1354	return false;
		1355
		1356	if (resultingCollections == null)
		1357	return true;
		1358
		1359	Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
		1360	VariableDeclarationCleanUp cleanUp= null;//new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		1361	FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 3, image, context);
		1362	resultingCollections.add(proposal);
		1363	return true;
		1364	}
1305	}	1365	}

Lines 48-53 Link Here

(-)ui/org/eclipse/jdt/internal/ui/fix/VariableDeclarationCleanUp.java (-2 / +29 lines)
48	*/	48	*/
49	public static final int ADD_FINAL_MODIFIER_LOCAL_VARIABLES= 4;	49	public static final int ADD_FINAL_MODIFIER_LOCAL_VARIABLES= 4;
50		50
		51	/**
		52	* Remove a qualified name and add an import instead
		53	* i.e.:<pre><code>
		54	* java.util.List l;->import java.util.List; ... List l;</code></pre>
		55	*/
		56	public static final int REPLACE_QUALIFIED_NAMES_WITH_IMPORT= 8;
		57
		58	/**
		59	* Fully qualify type names
		60	* i.e.:<pre><code>
		61	* import java.util.List;...List l;->java.util.List l;
		62	*/
		63	public static final int FULLY_QUALIFY_TYPE_NAMES= 16;
		64
51		65
52	private static final int DEFAULT_FLAG= 0;	66	private static final int DEFAULT_FLAG= 0;
53	private static final String SECTION_NAME= "CleanUp_VariableDeclarations"; //$NON-NLS-1$	67	private static final String SECTION_NAME= "CleanUp_VariableDeclarations"; //$NON-NLS-1$
Lines 70-76 Link Here
70	return VariableDeclarationFix.createCleanUp(compilationUnit,	84	return VariableDeclarationFix.createCleanUp(compilationUnit,
71	isFlag(ADD_FINAL_MODIFIER_FIELDS),	85	isFlag(ADD_FINAL_MODIFIER_FIELDS),
72	isFlag(ADD_FINAL_MODIFIER_PARAMETERS),	86	isFlag(ADD_FINAL_MODIFIER_PARAMETERS),
73	isFlag(ADD_FINAL_MODIFIER_LOCAL_VARIABLES));	87	isFlag(ADD_FINAL_MODIFIER_LOCAL_VARIABLES),
		88	isFlag(REPLACE_QUALIFIED_NAMES_WITH_IMPORT),
		89	isFlag(FULLY_QUALIFY_TYPE_NAMES));
74	}	90	}
75		91
76	/**	92	/**
Lines 103-108 Link Here
103	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalParameters_description);	119	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalParameters_description);
104	if (isFlag(ADD_FINAL_MODIFIER_LOCAL_VARIABLES))	120	if (isFlag(ADD_FINAL_MODIFIER_LOCAL_VARIABLES))
105	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalLocals_description);	121	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalLocals_description);
		122	if (isFlag(REPLACE_QUALIFIED_NAMES_WITH_IMPORT))
		123	result.add("Replace all qualified type names with import");
		124	if (isFlag(FULLY_QUALIFY_TYPE_NAMES))
		125	result.add("Fully qualify type names");
106		126
107	return (String[])result.toArray(new String[result.size()]);	127	return (String[])result.toArray(new String[result.size()]);
108	}	128	}
Lines 128-134 Link Here
128	buf.append(" int k, h;\n"); //$NON-NLS-1$	148	buf.append(" int k, h;\n"); //$NON-NLS-1$
129	buf.append(" h= 0;\n"); //$NON-NLS-1$	149	buf.append(" h= 0;\n"); //$NON-NLS-1$
130	}	150	}
131	buf.append("}\n"); //$NON-NLS-1$	151	buf.append("}\n\n"); //$NON-NLS-1$
		152
		153	if (isFlag(REPLACE_QUALIFIED_NAMES_WITH_IMPORT)) {
		154	buf.append("import java.util.List;\n"); //$NON-NLS-1$
		155	buf.append("List list;\n"); //$NON-NLS-1$
		156	} else {
		157	buf.append("java.util.List list;\n"); //$NON-NLS-1$
		158	}
132		159
133	return buf.toString();	160	return buf.toString();
134	}	161	}

Lines 748-755 Link Here

(-)ui/org/eclipse/jdt/internal/ui/fix/CleanUpRefactoringWizard.java (-2 / +7 lines)
748	FlagConfigurationGroup addFinalGroup= new FlagConfigurationGroup(MultiFixMessages.CleanUpRefactoringWizard_changeToFinal_checkBoxLabel, new FlagConfigurationButton[] {addFinalField, addFinalParam, addFinalLocal}, SWT.CHECK \| SWT.HORIZONTAL, settings);	748	FlagConfigurationGroup addFinalGroup= new FlagConfigurationGroup(MultiFixMessages.CleanUpRefactoringWizard_changeToFinal_checkBoxLabel, new FlagConfigurationButton[] {addFinalField, addFinalParam, addFinalLocal}, SWT.CHECK \| SWT.HORIZONTAL, settings);
749	addFinalGroup.createButton(group);	749	addFinalGroup.createButton(group);
750		750
751	FlagConfigurationButton[] flagConfigurationButtons= new FlagConfigurationButton[] {addBlock, removeBlock, removeBlockReturn, convertLoop, addParanoic, removeParanoic, addFinalField, addFinalParam, addFinalLocal};	751	FlagConfigurationButton alwaysQualify= new FlagConfigurationButton(varDeclCleanUp, VariableDeclarationCleanUp.FULLY_QUALIFY_TYPE_NAMES, "Always", SWT.RADIO);
752	FlagConfigurationGroup[] radioButtonGroups= new FlagConfigurationGroup[] {blockGroup, parenthesisGroup};	752	FlagConfigurationButton removeQualified= new FlagConfigurationButton(varDeclCleanUp, VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT, "Only where necessary", SWT.RADIO);
		753	FlagConfigurationGroup qualifieGroup= new FlagConfigurationGroup("Fully qualify type names", new FlagConfigurationButton[] {alwaysQualify, removeQualified}, SWT.RADIO \| SWT.HORIZONTAL, settings);
		754	qualifieGroup.createButton(group);
		755
		756	FlagConfigurationButton[] flagConfigurationButtons= new FlagConfigurationButton[] {addBlock, removeBlock, removeBlockReturn, convertLoop, addParanoic, removeParanoic, addFinalField, addFinalParam, addFinalLocal, alwaysQualify, removeQualified};
		757	FlagConfigurationGroup[] radioButtonGroups= new FlagConfigurationGroup[] {blockGroup, parenthesisGroup, qualifieGroup};
753	FlagConfigurationGroup[] checkBoxGroup= new FlagConfigurationGroup[] {addFinalGroup};	758	FlagConfigurationGroup[] checkBoxGroup= new FlagConfigurationGroup[] {addFinalGroup};
754		759
755	CleanUpPreview preview= addPreview(composite, new ICleanUp[] {controlStatementsCleanUp, expressionsCleanUp, varDeclCleanUp}, flagConfigurationButtons);	760	CleanUpPreview preview= addPreview(composite, new ICleanUp[] {controlStatementsCleanUp, expressionsCleanUp, varDeclCleanUp}, flagConfigurationButtons);

Lines 149-154 Link Here

(-)core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ImportRemover.java (+4 lines)
149	public boolean hasRemovedNodes() {	149	public boolean hasRemovedNodes() {
150	return fRemovedNodes.size() != 0;	150	return fRemovedNodes.size() != 0;
151	}	151	}
		152
		153	public ASTNode[] getRemovedNodes() {
		154	return (ASTNode[])fRemovedNodes.toArray(new ASTNode[fRemovedNodes.size()]);
		155	}
152		156
153	private boolean isInRemoved(SimpleName ref, int[] removedStartsEnds) {	157	private boolean isInRemoved(SimpleName ref, int[] removedStartsEnds) {
154	int start= ref.getStartPosition();	158	int start= ref.getStartPosition();




	public void testAddFinal01() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private int i= 0;\n");
		buf.append("    public void foo(int j, int k) {\n");

		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private final int i= 0;\n");
		buf.append("    public void foo(final int j, final int k) {\n");

	public void testAddFinal02() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private Object obj1;\n");
		buf.append("    protected Object obj2;\n");

		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private final Object obj1;\n");
		buf.append("    protected Object obj2;\n");

	public void testAddFinal03() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private int i = 0;\n");
		buf.append("    public void foo() throws Exception {\n");

		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private int i = 0;\n");
		buf.append("    public void foo() throws Exception {\n");

	public void testAddFinal04() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private int i = 0;\n");
		buf.append("    public void foo() throws Exception {\n");

		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    private int i = 0;\n");
		buf.append("    public void foo() throws Exception {\n");

	public void testAddFinal05() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        int i= 0;\n");

		refactoring.addCleanUp(new ExpressionsCleanUp(ExpressionsCleanUp.ADD_PARANOIC_PARENTHESIS));
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        final int i= 0;\n");

	public void testAddFinalBug129807() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public abstract class E {\n");
		buf.append("    public interface I {\n");
		buf.append("        void foo(int i);\n");

		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public abstract class E {\n");
		buf.append("    public interface I {\n");
		buf.append("        void foo(int i);\n");

		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
	public void testRemoveQualifiedNames01() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("import java.awt.List;\n");
		buf.append("package test1;\n");
		buf.append("public class E1 {\n");
		buf.append("    private java.util.BitSet set;\n");
		buf.append("    private void foo(java.util.AbstractList al) {\n");
		buf.append("        List awtList;\n");
		buf.append("        java.util.List l;\n");
		buf.append("        l= new java.util.ArrayList();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("import java.awt.List;\n");
		buf.append("import java.util.AbstractList;\n");
		buf.append("import java.util.ArrayList;\n");
		buf.append("import java.util.BitSet;\n");
		buf.append("package test1;\n");
		buf.append("public class E1 {\n");
		buf.append("    private BitSet set;\n");
		buf.append("    private void foo(AbstractList al) {\n");
		buf.append("        List awtList;\n");
		buf.append("        java.util.List l;\n");
		buf.append("        l= new ArrayList();\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();
		
		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
	public void testRemoveQualifiedNames02() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import test2.E2;\n");
		buf.append("public class E1 {\n");
		buf.append("    E2.Sub sub;\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
		buf= new StringBuffer();
		buf.append("package test2;\n");
		buf.append("public class E2 {\n");
		buf.append("    public class Sub {}\n");
		buf.append("}\n");
		pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import test2.E2.Sub;\n");
		buf.append("public class E1 {\n");
		buf.append("    Sub sub;\n");
		buf.append("}\n");
		String expected1= buf.toString();
		
		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
	public void testRemoveQualifiedNames03() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E1 {\n");
		buf.append("    private E1Sub.E1SubSub e1;\n");
		buf.append("    private static class E1Sub {\n");
		buf.append("        private static class E1SubSub {}\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		refactoring.addCleanUp(cleanUp);
		
		assertRefactoringHasNoChange(refactoring);
	}
	
	public void testRemoveQualifiedNames04() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E1 extends test2.E1 {}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
		buf= new StringBuffer();
		buf.append("package test2;\n");
		buf.append("public class E1 {}\n");
		pack2.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		refactoring.addCleanUp(cleanUp);
		
		assertRefactoringHasNoChange(refactoring);
	}
	
	public void testRemoveQualifiedNames05() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import test2.E2;\n");
		buf.append("public class E1 extends E2 {\n");
		buf.append("    E2.Sub sub;\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
		buf= new StringBuffer();
		buf.append("package test2;\n");
		buf.append("public class E2 {\n");
		buf.append("    public class Sub {}\n");
		buf.append("}\n");
		pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import test2.E2;\n");
		buf.append("public class E1 extends E2 {\n");
		buf.append("    Sub sub;\n");
		buf.append("}\n");
		String expected1= buf.toString();
		
		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
	public void testRemoveQualifiedNames06() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E1  {\n");
		buf.append("    java.util.List/*<Foo>*/l;\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n\n");
		buf.append("import java.util.List;\n\n");
		buf.append("public class E1  {\n");
		buf.append("    List/*<Foo>*/l;\n");
		buf.append("}\n");
		String expected1= buf.toString();
		
		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
	public void testQualifyNames01() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import java.util.List;\n");
		buf.append("public class E1  {\n");
		buf.append("    List/*<Foo>*/l;\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
		
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.FULLY_QUALIFY_TYPE_NAMES);
		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E1  {\n");
		buf.append("    java.util.List/*<Foo>*/l;\n");
		buf.append("}\n");
		String expected1= buf.toString();
		
		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
	public void testQualifiedNames02() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import test2.E2;\n");
		buf.append("public class E1 extends E2 {\n");
		buf.append("    public void foo() {\n");
		buf.append("        System.out.println(I);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		
		IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
		buf= new StringBuffer();
		buf.append("package test2;\n");
		buf.append("public class E2 {\n");
		buf.append("    public static int I;\n");
		buf.append("}\n");
		pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
		
		CleanUpRefactoring refactoring= new CleanUpRefactoring();
		refactoring.addCompilationUnit(cu1);
	
		refactoring.addCleanUp(new CodeStyleCleanUp(CodeStyleCleanUp.QUALIFY_STATIC_FIELD_ACCESS));
		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.FULLY_QUALIFY_TYPE_NAMES);
		refactoring.addCleanUp(cleanUp);
		
		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import test2.E2;\n");
		buf.append("public class E1 extends test2.E2 {\n");
		buf.append("    public void foo() {\n");
		buf.append("        System.out.println(E2.I);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();
		
		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
	}
	
//	public void testRemoveQualifiedNames06() throws Exception {
//		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
//		StringBuffer buf= new StringBuffer();
//		buf.append("package test1;\n");
//		buf.append("import test2.*;\n");
//		buf.append("public class E1 {\n");
//		buf.append("    E2.Sub sub;\n");
//		buf.append("}\n");
//		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
//		
//		IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
//		buf= new StringBuffer();
//		buf.append("package test2;\n");
//		buf.append("public class E2 {\n");
//		buf.append("    public class Sub {}\n");
//		buf.append("}\n");
//		pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
//		
//		CleanUpRefactoring refactoring= new CleanUpRefactoring();
//		refactoring.addCompilationUnit(cu1);
//		
//		ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
//		refactoring.addCleanUp(cleanUp);
//		
//		buf= new StringBuffer();
//		buf.append("package test1;\n");
//		buf.append("import test2.E2.Sub;\n");
//		buf.append("public class E1 {\n");
//		buf.append("    Sub sub;\n");
//		buf.append("}\n");
//		String expected1= buf.toString();
//		
//		assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
//	}
	
}

Return to bug 112999

Lines 49-54 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/CleanUpRefactoring.java (-1 / +16 lines)
49	import org.eclipse.jdt.core.JavaCore;	49	import org.eclipse.jdt.core.JavaCore;
50	import org.eclipse.jdt.core.JavaModelException;	50	import org.eclipse.jdt.core.JavaModelException;
51	import org.eclipse.jdt.core.WorkingCopyOwner;	51	import org.eclipse.jdt.core.WorkingCopyOwner;
		52	import org.eclipse.jdt.core.dom.ASTNode;
52	import org.eclipse.jdt.core.dom.ASTParser;	53	import org.eclipse.jdt.core.dom.ASTParser;
53	import org.eclipse.jdt.core.dom.ASTRequestor;	54	import org.eclipse.jdt.core.dom.ASTRequestor;
54	import org.eclipse.jdt.core.dom.CompilationUnit;	55	import org.eclipse.jdt.core.dom.CompilationUnit;
Lines 58-63 Link Here
58	import org.eclipse.jdt.internal.corext.refactoring.changes.DynamicValidationStateChange;	59	import org.eclipse.jdt.internal.corext.refactoring.changes.DynamicValidationStateChange;
59	import org.eclipse.jdt.internal.corext.refactoring.changes.TextChangeCompatibility;	60	import org.eclipse.jdt.internal.corext.refactoring.changes.TextChangeCompatibility;
60	import org.eclipse.jdt.internal.corext.refactoring.composite.MultiStateCompilationUnitChange;	61	import org.eclipse.jdt.internal.corext.refactoring.composite.MultiStateCompilationUnitChange;
		62	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
61	import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;	63	import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;
62	import org.eclipse.jdt.internal.corext.util.Messages;	64	import org.eclipse.jdt.internal.corext.util.Messages;
63		65
Lines 221-226 Link Here
221	}	223	}
222		224
223	private ParseListElement calculateSolution(Hashtable solutions, CompilationUnit ast, ICleanUp[] cleanUps) {	225	private ParseListElement calculateSolution(Hashtable solutions, CompilationUnit ast, ICleanUp[] cleanUps) {
		226	CompilationUnitRewrite cuRewrite= new CompilationUnitRewrite((ICompilationUnit)ast.getJavaElement(), ast);
224	TextChange solution= null;	227	TextChange solution= null;
225	ParseListElement result= null;	228	ParseListElement result= null;
226	for (int i= 0; i < cleanUps.length; i++) {	229	for (int i= 0; i < cleanUps.length; i++) {
Lines 228-234 Link Here
228	try {	231	try {
229	IFix fix= cleanUp.createFix(ast);	232	IFix fix= cleanUp.createFix(ast);
230	if (fix != null) {	233	if (fix != null) {
231	TextChange current= fix.createChange();	234	CompilationUnitRewrite curr= new CompilationUnitRewrite((ICompilationUnit)ast.getJavaElement(), ast);
		235	ASTNode[] removedNodes= cuRewrite.getImportRemover().getRemovedNodes();
		236	for (int j= 0; j < removedNodes.length; j++) {
		237	curr.getImportRemover().registerRemovedNode(removedNodes[j]);
		238	}
		239	String[] addedImports= cuRewrite.getImportRewrite().getAddedImports();
		240	for (int j= 0; j < addedImports.length; j++) {
		241	curr.getImportRewrite().addImport(addedImports[j]);
		242	curr.getImportRemover().registerAddedImport(addedImports[j]);
		243	}
		244	TextChange current= fix.createChange(curr);
232	if (current instanceof TextFileChange && fLeaveFilesDirty)	245	if (current instanceof TextFileChange && fLeaveFilesDirty)
233	((TextFileChange)current).setSaveMode(TextFileChange.LEAVE_DIRTY);	246	((TextFileChange)current).setSaveMode(TextFileChange.LEAVE_DIRTY);
234		247
Lines 241-249 Link Here
241	} else {	254	} else {
242	mergeTextChanges(current, solution);	255	mergeTextChanges(current, solution);
243	solution= current;	256	solution= current;
		257	cuRewrite= curr;
244	}	258	}
245	} else {	259	} else {
246	solution= current;	260	solution= current;
		261	cuRewrite= curr;
247	}	262	}
248	}	263	}
249	} catch (CoreException e) {	264	} catch (CoreException e) {

Lines 22-28 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/LinkedFix.java (-4 / +1 lines)
22		22
23	import org.eclipse.ltk.core.refactoring.TextChange;	23	import org.eclipse.ltk.core.refactoring.TextChange;
24		24
25	import org.eclipse.jdt.core.ICompilationUnit;
26	import org.eclipse.jdt.core.dom.CompilationUnit;	25	import org.eclipse.jdt.core.dom.CompilationUnit;
27	import org.eclipse.jdt.core.dom.rewrite.ITrackedNodePosition;	26	import org.eclipse.jdt.core.dom.rewrite.ITrackedNodePosition;
28		27
Lines 88-98 Link Here
88	/* (non-Javadoc)	87	/* (non-Javadoc)
89	* @see org.eclipse.jdt.internal.corext.fix.IFix#createChange()	88	* @see org.eclipse.jdt.internal.corext.fix.IFix#createChange()
90	*/	89	*/
91	public TextChange createChange() throws CoreException {	90	public TextChange createChange(CompilationUnitRewrite cuRewrite) throws CoreException {
92	if (fFixRewrites == null \|\| fFixRewrites.length == 0)	91	if (fFixRewrites == null \|\| fFixRewrites.length == 0)
93	return null;	92	return null;
94
95	CompilationUnitRewrite cuRewrite= new CompilationUnitRewrite((ICompilationUnit)fCompilationUnit.getJavaElement(), fCompilationUnit);
96		93
97	List/<TextEditGroup>/ groups= new ArrayList();	94	List/<TextEditGroup>/ groups= new ArrayList();
98		95

Lines 4485-4491 Link Here

(-)ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java (-12 / +292 lines)
4485	public void testAddFinal01() throws Exception {	4485	public void testAddFinal01() throws Exception {
4486	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	4486	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4487	StringBuffer buf= new StringBuffer();	4487	StringBuffer buf= new StringBuffer();
4488	buf.append("package test;\n");	4488	buf.append("package test1;\n");
4489	buf.append("public class E {\n");	4489	buf.append("public class E {\n");
4490	buf.append(" private int i= 0;\n");	4490	buf.append(" private int i= 0;\n");
4491	buf.append(" public void foo(int j, int k) {\n");	4491	buf.append(" public void foo(int j, int k) {\n");
Lines 4502-4508 Link Here
4502	refactoring.addCleanUp(cleanUp);	4502	refactoring.addCleanUp(cleanUp);
4503		4503
4504	buf= new StringBuffer();	4504	buf= new StringBuffer();
4505	buf.append("package test;\n");	4505	buf.append("package test1;\n");
4506	buf.append("public class E {\n");	4506	buf.append("public class E {\n");
4507	buf.append(" private final int i= 0;\n");	4507	buf.append(" private final int i= 0;\n");
4508	buf.append(" public void foo(final int j, final int k) {\n");	4508	buf.append(" public void foo(final int j, final int k) {\n");
Lines 4519-4525 Link Here
4519	public void testAddFinal02() throws Exception {	4519	public void testAddFinal02() throws Exception {
4520	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	4520	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4521	StringBuffer buf= new StringBuffer();	4521	StringBuffer buf= new StringBuffer();
4522	buf.append("package test;\n");	4522	buf.append("package test1;\n");
4523	buf.append("public class E {\n");	4523	buf.append("public class E {\n");
4524	buf.append(" private Object obj1;\n");	4524	buf.append(" private Object obj1;\n");
4525	buf.append(" protected Object obj2;\n");	4525	buf.append(" protected Object obj2;\n");
Lines 4535-4541 Link Here
4535	refactoring.addCleanUp(cleanUp);	4535	refactoring.addCleanUp(cleanUp);
4536		4536
4537	buf= new StringBuffer();	4537	buf= new StringBuffer();
4538	buf.append("package test;\n");	4538	buf.append("package test1;\n");
4539	buf.append("public class E {\n");	4539	buf.append("public class E {\n");
4540	buf.append(" private final Object obj1;\n");	4540	buf.append(" private final Object obj1;\n");
4541	buf.append(" protected Object obj2;\n");	4541	buf.append(" protected Object obj2;\n");
Lines 4550-4556 Link Here
4550	public void testAddFinal03() throws Exception {	4550	public void testAddFinal03() throws Exception {
4551	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	4551	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4552	StringBuffer buf= new StringBuffer();	4552	StringBuffer buf= new StringBuffer();
4553	buf.append("package test;\n");	4553	buf.append("package test1;\n");
4554	buf.append("public class E {\n");	4554	buf.append("public class E {\n");
4555	buf.append(" private int i = 0;\n");	4555	buf.append(" private int i = 0;\n");
4556	buf.append(" public void foo() throws Exception {\n");	4556	buf.append(" public void foo() throws Exception {\n");
Lines 4572-4578 Link Here
4572	refactoring.addCleanUp(cleanUp);	4572	refactoring.addCleanUp(cleanUp);
4573		4573
4574	buf= new StringBuffer();	4574	buf= new StringBuffer();
4575	buf.append("package test;\n");	4575	buf.append("package test1;\n");
4576	buf.append("public class E {\n");	4576	buf.append("public class E {\n");
4577	buf.append(" private int i = 0;\n");	4577	buf.append(" private int i = 0;\n");
4578	buf.append(" public void foo() throws Exception {\n");	4578	buf.append(" public void foo() throws Exception {\n");
Lines 4593-4599 Link Here
4593	public void testAddFinal04() throws Exception {	4593	public void testAddFinal04() throws Exception {
4594	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	4594	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4595	StringBuffer buf= new StringBuffer();	4595	StringBuffer buf= new StringBuffer();
4596	buf.append("package test;\n");	4596	buf.append("package test1;\n");
4597	buf.append("public class E {\n");	4597	buf.append("public class E {\n");
4598	buf.append(" private int i = 0;\n");	4598	buf.append(" private int i = 0;\n");
4599	buf.append(" public void foo() throws Exception {\n");	4599	buf.append(" public void foo() throws Exception {\n");
Lines 4615-4621 Link Here
4615	refactoring.addCleanUp(cleanUp);	4615	refactoring.addCleanUp(cleanUp);
4616		4616
4617	buf= new StringBuffer();	4617	buf= new StringBuffer();
4618	buf.append("package test;\n");	4618	buf.append("package test1;\n");
4619	buf.append("public class E {\n");	4619	buf.append("public class E {\n");
4620	buf.append(" private int i = 0;\n");	4620	buf.append(" private int i = 0;\n");
4621	buf.append(" public void foo() throws Exception {\n");	4621	buf.append(" public void foo() throws Exception {\n");
Lines 4636-4642 Link Here
4636	public void testAddFinal05() throws Exception {	4636	public void testAddFinal05() throws Exception {
4637	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	4637	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4638	StringBuffer buf= new StringBuffer();	4638	StringBuffer buf= new StringBuffer();
4639	buf.append("package test;\n");	4639	buf.append("package test1;\n");
4640	buf.append("public class E {\n");	4640	buf.append("public class E {\n");
4641	buf.append(" public void foo() {\n");	4641	buf.append(" public void foo() {\n");
4642	buf.append(" int i= 0;\n");	4642	buf.append(" int i= 0;\n");
Lines 4654-4660 Link Here
4654	refactoring.addCleanUp(new ExpressionsCleanUp(ExpressionsCleanUp.ADD_PARANOIC_PARENTHESIS));	4654	refactoring.addCleanUp(new ExpressionsCleanUp(ExpressionsCleanUp.ADD_PARANOIC_PARENTHESIS));
4655		4655
4656	buf= new StringBuffer();	4656	buf= new StringBuffer();
4657	buf.append("package test;\n");	4657	buf.append("package test1;\n");
4658	buf.append("public class E {\n");	4658	buf.append("public class E {\n");
4659	buf.append(" public void foo() {\n");	4659	buf.append(" public void foo() {\n");
4660	buf.append(" final int i= 0;\n");	4660	buf.append(" final int i= 0;\n");
Lines 4670-4676 Link Here
4670	public void testAddFinalBug129807() throws Exception {	4670	public void testAddFinalBug129807() throws Exception {
4671	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	4671	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4672	StringBuffer buf= new StringBuffer();	4672	StringBuffer buf= new StringBuffer();
4673	buf.append("package test;\n");	4673	buf.append("package test1;\n");
4674	buf.append("public abstract class E {\n");	4674	buf.append("public abstract class E {\n");
4675	buf.append(" public interface I {\n");	4675	buf.append(" public interface I {\n");
4676	buf.append(" void foo(int i);\n");	4676	buf.append(" void foo(int i);\n");
Lines 4690-4696 Link Here
4690	refactoring.addCleanUp(cleanUp);	4690	refactoring.addCleanUp(cleanUp);
4691		4691
4692	buf= new StringBuffer();	4692	buf= new StringBuffer();
4693	buf.append("package test;\n");	4693	buf.append("package test1;\n");
4694	buf.append("public abstract class E {\n");	4694	buf.append("public abstract class E {\n");
4695	buf.append(" public interface I {\n");	4695	buf.append(" public interface I {\n");
4696	buf.append(" void foo(int i);\n");	4696	buf.append(" void foo(int i);\n");
Lines 4767-4770 Link Here
4767	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});	4767	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
4768	}	4768	}
4769		4769
		4770	public void testRemoveQualifiedNames01() throws Exception {
		4771	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		4772	StringBuffer buf= new StringBuffer();
		4773	buf.append("import java.awt.List;\n");
		4774	buf.append("package test1;\n");
		4775	buf.append("public class E1 {\n");
		4776	buf.append(" private java.util.BitSet set;\n");
		4777	buf.append(" private void foo(java.util.AbstractList al) {\n");
		4778	buf.append(" List awtList;\n");
		4779	buf.append(" java.util.List l;\n");
		4780	buf.append(" l= new java.util.ArrayList();\n");
		4781	buf.append(" }\n");
		4782	buf.append("}\n");
		4783	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		4784
		4785	CleanUpRefactoring refactoring= new CleanUpRefactoring();
		4786	refactoring.addCompilationUnit(cu1);
		4787
		4788	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		4789	refactoring.addCleanUp(cleanUp);
		4790
		4791	buf= new StringBuffer();
		4792	buf.append("import java.awt.List;\n");
		4793	buf.append("import java.util.AbstractList;\n");
		4794	buf.append("import java.util.ArrayList;\n");
		4795	buf.append("import java.util.BitSet;\n");
		4796	buf.append("package test1;\n");
		4797	buf.append("public class E1 {\n");
		4798	buf.append(" private BitSet set;\n");
		4799	buf.append(" private void foo(AbstractList al) {\n");
		4800	buf.append(" List awtList;\n");
		4801	buf.append(" java.util.List l;\n");
		4802	buf.append(" l= new ArrayList();\n");
		4803	buf.append(" }\n");
		4804	buf.append("}\n");
		4805	String expected1= buf.toString();
		4806
		4807	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
		4808	}
		4809
		4810	public void testRemoveQualifiedNames02() throws Exception {
		4811	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		4812	StringBuffer buf= new StringBuffer();
		4813	buf.append("package test1;\n");
		4814	buf.append("import test2.E2;\n");
		4815	buf.append("public class E1 {\n");
		4816	buf.append(" E2.Sub sub;\n");
		4817	buf.append("}\n");
		4818	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
		4819
		4820	IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
		4821	buf= new StringBuffer();
		4822	buf.append("package test2;\n");
		4823	buf.append("public class E2 {\n");
		4824	buf.append(" public class Sub {}\n");
		4825	buf.append("}\n");
		4826	pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
		4827
		4828	CleanUpRefactoring refactoring= new CleanUpRefactoring();
		4829	refactoring.addCompilationUnit(cu1);
		4830
		4831	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
		4832	refactoring.addCleanUp(cleanUp);
		4833
4834	buf= new StringBuffer();
4835	buf.append("package test1;\n");
4836	buf.append("import test2.E2.Sub;\n");
4837	buf.append("public class E1 {\n");
4838	buf.append(" Sub sub;\n");
4839	buf.append("}\n");
4840	String expected1= buf.toString();
4841
4842	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
4843	}
4844
4845	public void testRemoveQualifiedNames03() throws Exception {
4846	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4847	StringBuffer buf= new StringBuffer();
4848	buf.append("package test1;\n");
4849	buf.append("public class E1 {\n");
4850	buf.append(" private E1Sub.E1SubSub e1;\n");
4851	buf.append(" private static class E1Sub {\n");
4852	buf.append(" private static class E1SubSub {}\n");
4853	buf.append(" }\n");
4854	buf.append("}\n");
4855	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
4856
4857	CleanUpRefactoring refactoring= new CleanUpRefactoring();
4858	refactoring.addCompilationUnit(cu1);
4859
4860	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
4861	refactoring.addCleanUp(cleanUp);
4862
4863	assertRefactoringHasNoChange(refactoring);
4864	}
4865
4866	public void testRemoveQualifiedNames04() throws Exception {
4867	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4868	StringBuffer buf= new StringBuffer();
4869	buf.append("package test1;\n");
4870	buf.append("public class E1 extends test2.E1 {}\n");
4871	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
4872
4873	IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
4874	buf= new StringBuffer();
4875	buf.append("package test2;\n");
4876	buf.append("public class E1 {}\n");
4877	pack2.createCompilationUnit("E1.java", buf.toString(), false, null);
4878
4879	CleanUpRefactoring refactoring= new CleanUpRefactoring();
4880	refactoring.addCompilationUnit(cu1);
4881
4882	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
4883	refactoring.addCleanUp(cleanUp);
4884
4885	assertRefactoringHasNoChange(refactoring);
4886	}
4887
4888	public void testRemoveQualifiedNames05() throws Exception {
4889	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4890	StringBuffer buf= new StringBuffer();
4891	buf.append("package test1;\n");
4892	buf.append("import test2.E2;\n");
4893	buf.append("public class E1 extends E2 {\n");
4894	buf.append(" E2.Sub sub;\n");
4895	buf.append("}\n");
4896	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
4897
4898	IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
4899	buf= new StringBuffer();
4900	buf.append("package test2;\n");
4901	buf.append("public class E2 {\n");
4902	buf.append(" public class Sub {}\n");
4903	buf.append("}\n");
4904	pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
4905
4906	CleanUpRefactoring refactoring= new CleanUpRefactoring();
4907	refactoring.addCompilationUnit(cu1);
4908
4909	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
4910	refactoring.addCleanUp(cleanUp);
4911
4912	buf= new StringBuffer();
4913	buf.append("package test1;\n");
4914	buf.append("import test2.E2;\n");
4915	buf.append("public class E1 extends E2 {\n");
4916	buf.append(" Sub sub;\n");
4917	buf.append("}\n");
4918	String expected1= buf.toString();
4919
4920	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
4921	}
4922
4923	public void testRemoveQualifiedNames06() throws Exception {
4924	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4925	StringBuffer buf= new StringBuffer();
4926	buf.append("package test1;\n");
4927	buf.append("public class E1 {\n");
4928	buf.append(" java.util.List/<Foo>/l;\n");
4929	buf.append("}\n");
4930	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
4931
4932	CleanUpRefactoring refactoring= new CleanUpRefactoring();
4933	refactoring.addCompilationUnit(cu1);
4934
4935	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
4936	refactoring.addCleanUp(cleanUp);
4937
4938	buf= new StringBuffer();
4939	buf.append("package test1;\n\n");
4940	buf.append("import java.util.List;\n\n");
4941	buf.append("public class E1 {\n");
4942	buf.append(" List/<Foo>/l;\n");
4943	buf.append("}\n");
4944	String expected1= buf.toString();
4945
4946	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
4947	}
4948
4949	public void testQualifyNames01() throws Exception {
4950	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4951	StringBuffer buf= new StringBuffer();
4952	buf.append("package test1;\n");
4953	buf.append("import java.util.List;\n");
4954	buf.append("public class E1 {\n");
4955	buf.append(" List/<Foo>/l;\n");
4956	buf.append("}\n");
4957	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
4958
4959	CleanUpRefactoring refactoring= new CleanUpRefactoring();
4960	refactoring.addCompilationUnit(cu1);
4961
4962	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.FULLY_QUALIFY_TYPE_NAMES);
4963	refactoring.addCleanUp(cleanUp);
4964
4965	buf= new StringBuffer();
4966	buf.append("package test1;\n");
4967	buf.append("public class E1 {\n");
4968	buf.append(" java.util.List/<Foo>/l;\n");
4969	buf.append("}\n");
4970	String expected1= buf.toString();
4971
4972	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
4973	}
4974
4975	public void testQualifiedNames02() throws Exception {
4976	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
4977	StringBuffer buf= new StringBuffer();
4978	buf.append("package test1;\n");
4979	buf.append("import test2.E2;\n");
4980	buf.append("public class E1 extends E2 {\n");
4981	buf.append(" public void foo() {\n");
4982	buf.append(" System.out.println(I);\n");
4983	buf.append(" }\n");
4984	buf.append("}\n");
4985	ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
4986
4987	IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
4988	buf= new StringBuffer();
4989	buf.append("package test2;\n");
4990	buf.append("public class E2 {\n");
4991	buf.append(" public static int I;\n");
4992	buf.append("}\n");
4993	pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
4994
4995	CleanUpRefactoring refactoring= new CleanUpRefactoring();
4996	refactoring.addCompilationUnit(cu1);
4997
4998	refactoring.addCleanUp(new CodeStyleCleanUp(CodeStyleCleanUp.QUALIFY_STATIC_FIELD_ACCESS));
4999	ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.FULLY_QUALIFY_TYPE_NAMES);
5000	refactoring.addCleanUp(cleanUp);
5001
5002	buf= new StringBuffer();
5003	buf.append("package test1;\n");
5004	buf.append("import test2.E2;\n");
5005	buf.append("public class E1 extends test2.E2 {\n");
5006	buf.append(" public void foo() {\n");
5007	buf.append(" System.out.println(E2.I);\n");
5008	buf.append(" }\n");
5009	buf.append("}\n");
5010	String expected1= buf.toString();
5011
5012	assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
5013	}
5014
5015	// public void testRemoveQualifiedNames06() throws Exception {
5016	// IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
5017	// StringBuffer buf= new StringBuffer();
5018	// buf.append("package test1;\n");
5019	// buf.append("import test2.*;\n");
5020	// buf.append("public class E1 {\n");
5021	// buf.append(" E2.Sub sub;\n");
5022	// buf.append("}\n");
5023	// ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
5024	//
5025	// IPackageFragment pack2= fSourceFolder.createPackageFragment("test2", false, null);
5026	// buf= new StringBuffer();
5027	// buf.append("package test2;\n");
5028	// buf.append("public class E2 {\n");
5029	// buf.append(" public class Sub {}\n");
5030	// buf.append("}\n");
5031	// pack2.createCompilationUnit("E2.java", buf.toString(), false, null);
5032	//
5033	// CleanUpRefactoring refactoring= new CleanUpRefactoring();
5034	// refactoring.addCompilationUnit(cu1);
5035	//
5036	// ICleanUp cleanUp= new VariableDeclarationCleanUp(VariableDeclarationCleanUp.REPLACE_QUALIFIED_NAMES_WITH_IMPORT);
5037	// refactoring.addCleanUp(cleanUp);
5038	//
5039	// buf= new StringBuffer();
5040	// buf.append("package test1;\n");
5041	// buf.append("import test2.E2.Sub;\n");
5042	// buf.append("public class E1 {\n");
5043	// buf.append(" Sub sub;\n");
5044	// buf.append("}\n");
5045	// String expected1= buf.toString();
5046	//
5047	// assertRefactoringResultAsExpected(refactoring, new String[] {expected1});
5048	// }
5049
4770	}	5050	}