Attachment #240476 for bug #426967




/*******************************************************************************
 * Copyright (c) 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * This is an implementation of an early-draft specification developed under the Java
 * Community Process (JCP) and is made available for testing and evaluation purposes
 * only. The code is not compatible with any specification of the JCP.
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.dom;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.AnnotatableType;
import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
import org.eclipse.jdt.core.dom.ArrayType;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.IAnnotationBinding;
import org.eclipse.jdt.core.dom.IExtendedModifier;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.UnionType;
import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

import org.eclipse.jdt.internal.corext.util.JDTUIHelperClasses;

/**
 * Rewrite helper for type annotations part of the declaration's modifiers of a type reference.
 * 
 * @see JDTUIHelperClasses
 * @since 3.9 BETA_JAVA8
 */
public class DeclarationRewrite {

	/**
	 * Creates a copy of the given <code>typeNode</code> and adds its type annotations to the copied
	 * type by removing them from its declaration's modifiers.
	 * 
	 * @param typeNode the Type node
	 * @param rewrite the ASTRewrite with which to create new nodes
	 * @param editGroup the edit group in which to collect the corresponding text edits, or null if
	 *            ungrouped
	 * @return copy of the type node with added type annotations
	 */
	public static Type copyTypeAndMoveTypeAnnotations(Type typeNode, ASTRewrite rewrite, TextEditGroup editGroup) {
		Type copiedtypeNode= copyTypeAndAddTypeAnnotations(typeNode, rewrite);
		removeTypeAnnotationsFromDeclaration(typeNode, rewrite, editGroup);
		return copiedtypeNode;
	}

	/**
	 * Creates a copy of the given <code>typeNode</code> and adds its type annotations to the copied
	 * type by copying them from its declaration's modifiers. The type annotations are not removed
	 * from the declaration node.
	 * 
	 * @param typeNode the Type node
	 * @param rewrite the ASTRewrite with which to create new nodes
	 * @return copy of the type node with added type annotations
	 */
	public static Type copyTypeAndAddTypeAnnotations(Type typeNode, ASTRewrite rewrite) {
		if (!(typeNode instanceof AnnotatableType || (typeNode instanceof ArrayType && ((ArrayType) typeNode).getElementType() instanceof AnnotatableType)))
			return (Type) rewrite.createCopyTarget(typeNode);

		List<Annotation> typeAnnotations= DeclarationRewrite.getTypeAnnotationsOnDeclaration(typeNode);
		if (typeAnnotations.isEmpty())
			return (Type) rewrite.createCopyTarget(typeNode);

		Type copiedTypeNode= (Type) ASTNode.copySubtree(rewrite.getAST(), typeNode);
		AnnotatableType copiedAnnotatableType;
		if (copiedTypeNode instanceof ArrayType) {
			copiedAnnotatableType= (AnnotatableType) ((ArrayType) copiedTypeNode).getElementType();
		} else {
			copiedAnnotatableType= (AnnotatableType) copiedTypeNode;
		}
		for (Annotation annotation : typeAnnotations) {
			copiedAnnotatableType.annotations().add(rewrite.createCopyTarget(annotation));
		}
		return copiedTypeNode;
	}

	/**
	 * Removes type annotations of the given <code>typeNode</code> from its declaration's modifiers.
	 * 
	 * @param typeNode the Type node
	 * @param rewrite rewrite that removes the nodes
	 * @param editGroup the edit group in which to collect the corresponding text edits, or null if
	 *            ungrouped
	 */
	public static void removeTypeAnnotationsFromDeclaration(Type typeNode, ASTRewrite rewrite, TextEditGroup editGroup) {
		List<Annotation> typeAnnotations= DeclarationRewrite.getTypeAnnotationsOnDeclaration(typeNode);
		for (Annotation annotation : typeAnnotations) {
			rewrite.remove(annotation, editGroup);
		}
	}

	private static List<Annotation> getTypeAnnotationsOnDeclaration(Type typeNode) {
		ITypeBinding typeBinding= typeNode.resolveBinding();
		if (typeBinding == null)
			return Collections.emptyList();

		List<IAnnotationBinding> typeAnnotationBindings;
		if (typeBinding.isArray()) {
			typeAnnotationBindings= Arrays.asList(typeBinding.getElementType().getTypeAnnotations());
		} else {
			typeAnnotationBindings= Arrays.asList(typeBinding.getTypeAnnotations());
		}

		if (typeAnnotationBindings.size() == 0)
			return Collections.emptyList();

		List<IExtendedModifier> declarationModifiers= new ArrayList<IExtendedModifier>();
		StructuralPropertyDescriptor locationInParent= typeNode.getLocationInParent();

		if (locationInParent == UnionType.TYPES_PROPERTY) {
			typeNode= (UnionType) typeNode.getParent();
			locationInParent= typeNode.getLocationInParent();
		}

		if (locationInParent == ArrayType.ELEMENT_TYPE_PROPERTY) {
			typeNode= (ArrayType) typeNode.getParent();
			locationInParent= typeNode.getLocationInParent();
		}

		if (locationInParent == MethodDeclaration.RETURN_TYPE2_PROPERTY) {
			declarationModifiers= ((MethodDeclaration) typeNode.getParent()).modifiers();
		} else if (locationInParent == FieldDeclaration.TYPE_PROPERTY) {
			declarationModifiers= ((FieldDeclaration) typeNode.getParent()).modifiers();
		} else if (locationInParent == VariableDeclarationExpression.TYPE_PROPERTY) {
			declarationModifiers= ((VariableDeclarationExpression) typeNode.getParent()).modifiers();
		} else if (locationInParent == VariableDeclarationStatement.TYPE_PROPERTY) {
			declarationModifiers= ((VariableDeclarationStatement) typeNode.getParent()).modifiers();
		} else if (locationInParent == SingleVariableDeclaration.TYPE_PROPERTY) {
			declarationModifiers= ((SingleVariableDeclaration) typeNode.getParent()).modifiers();
		} else if (locationInParent == AnnotationTypeMemberDeclaration.TYPE_PROPERTY) {
			declarationModifiers= ((AnnotationTypeMemberDeclaration) typeNode.getParent()).modifiers();
		}

		return getTypeAnnotationsFromModifiers(declarationModifiers, typeAnnotationBindings);
	}

	private static List<Annotation> getTypeAnnotationsFromModifiers(List<IExtendedModifier> modifiers, List<IAnnotationBinding> typeAnnotationBindings) {
		List<Annotation> typeAnnotations= new ArrayList<Annotation>();
		for (IExtendedModifier modifier : modifiers) {
			if (modifier.isAnnotation()) {
				IAnnotationBinding modifierAnnotationBinding= ((Annotation) modifier).resolveAnnotationBinding();
				if (typeAnnotationBindings.contains(modifierAnnotationBinding)) {
					typeAnnotations.add((Annotation) modifier);
				}
			}
		}
		return typeAnnotations;
	}
}




/*******************************************************************************
 * Copyright (c) 2013, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public class DimensionRewrite {

	/**
	 * Creates a {@link DeclarationRewrite#copyTypeAndAddTypeAnnotations(Type, ASTRewrite) copy} of <code>type</code>
	 * and adds <code>extraDimensions</code> to it.
	 * 
	 * @param type the type to copy

	public static Type copyTypeAndAddDimensions(Type type, List<Dimension> extraDimensions, ASTRewrite rewrite) {
		AST ast= rewrite.getAST();
		if (extraDimensions.isEmpty()) {
			return DeclarationRewrite.copyTypeAndAddTypeAnnotations(type, rewrite);
		}
		
		ArrayType result;
		if (type instanceof ArrayType) {
			ArrayType arrayType= (ArrayType) type;
			Type varElementType= DeclarationRewrite.copyTypeAndAddTypeAnnotations(arrayType.getElementType(), rewrite);
			result= ast.newArrayType(varElementType, 0);
			result.dimensions().addAll(copyDimensions(extraDimensions, rewrite));
			result.dimensions().addAll(copyDimensions(arrayType.dimensions(), rewrite));
		} else {
			Type elementType= DeclarationRewrite.copyTypeAndAddTypeAnnotations(type, rewrite);
			result= ast.newArrayType(elementType, 0);
			result.dimensions().addAll(copyDimensions(extraDimensions, rewrite));
		}

Lines 1-9 Link Here

(-)a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/UnusedCodeFix.java (-2 / +7 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2013 IBM Corporation and others.	2	* Copyright (c) 2000, 2014 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
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	*
		8	* This is an implementation of an early-draft specification developed under the Java
		9	* Community Process (JCP) and is made available for testing and evaluation purposes
		10	* only. The code is not compatible with any specification of the JCP.
7	*	11	*
8	* Contributors:	12	* Contributors:
9	* IBM Corporation - initial API and implementation	13	* IBM Corporation - initial API and implementation
Lines 63-68 Link Here
63	import org.eclipse.jdt.core.dom.rewrite.ListRewrite;	67	import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
64		68
65	import org.eclipse.jdt.internal.corext.dom.ASTNodes;	69	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
		70	import org.eclipse.jdt.internal.corext.dom.DeclarationRewrite;
66	import org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder;	71	import org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder;
67	import org.eclipse.jdt.internal.corext.dom.NecessaryParenthesesChecker;	72	import org.eclipse.jdt.internal.corext.dom.NecessaryParenthesesChecker;
68	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;	73	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
Lines 392-398 Link Here
392	VariableDeclarationFragment movedFragment= (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment);	397	VariableDeclarationFragment movedFragment= (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment);
393	if (newDeclaration == null) {	398	if (newDeclaration == null) {
394	newDeclaration= rewrite.getAST().newVariableDeclarationStatement(movedFragment);	399	newDeclaration= rewrite.getAST().newVariableDeclarationStatement(movedFragment);
395	Type copiedType= (Type) rewrite.createCopyTarget(originalStatement.getType());	400	Type copiedType= DeclarationRewrite.copyTypeAndAddTypeAnnotations(originalStatement.getType(), rewrite);
396	newDeclaration.setType(copiedType);	401	newDeclaration.setType(copiedType);
397	} else	402	} else
398	newDeclaration.fragments().add(movedFragment);	403	newDeclaration.fragments().add(movedFragment);




/*******************************************************************************
 * Copyright (c) 2000, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.dom.DeclarationRewrite;
import org.eclipse.jdt.internal.corext.dom.DimensionRewrite;
import org.eclipse.jdt.internal.corext.dom.VariableDeclarationRewrite;
import org.eclipse.jdt.internal.corext.refactoring.Checks;

		result.setName(ast.newSimpleName(fSetterName));
		result.modifiers().addAll(ASTNodeFactory.newModifiers(ast, createModifiers()));
		if (fSetterMustReturnValue) {
			Type copiedType= DimensionRewrite.copyTypeAndAddDimensions(type, fFieldDeclaration.extraDimensions(), rewriter);
			result.setReturnType2(copiedType);
		}
		SingleVariableDeclaration param= ast.newSingleVariableDeclaration();
		result.parameters().add(param);
		param.setName(ast.newSimpleName(fArgName));
		Type copiedType= DeclarationRewrite.copyTypeAndAddTypeAnnotations(type, rewriter);
		param.setType(copiedType);
		List<Dimension> extraDimensions= DimensionRewrite.copyDimensions(fFieldDeclaration.extraDimensions(), rewriter);
		param.extraDimensions().addAll(extraDimensions);





import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.dom.DeclarationRewrite;
import org.eclipse.jdt.internal.corext.dom.DimensionRewrite;
import org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder;
import org.eclipse.jdt.internal.corext.dom.ModifierRewrite;

			VariableDeclarationExpression oldVarDecl= (VariableDeclarationExpression) fragParent;

			VariableDeclarationStatement newVarDec= ast.newVariableDeclarationStatement(newFrag);
			Type copiedTypeNode= DeclarationRewrite.copyTypeAndAddTypeAnnotations(oldVarDecl.getType(), rewrite);
			newVarDec.setType(copiedTypeNode);
			newVarDec.modifiers().addAll(ASTNodeFactory.newModifiers(ast, oldVarDecl.getModifiers()));
			newStatement= newVarDec;
		}

			ASTRewrite rewrite= ASTRewrite.create(ast);
			if (selectedMultiCatchType != null) {
				removeException(rewrite, (UnionType) type, selectedMultiCatchType);
				addExceptionToThrows(methodDeclaration, rewrite, selectedMultiCatchType);
				String label= CorrectionMessages.QuickAssistProcessor_exceptiontothrows_description;
				ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REPLACE_EXCEPTION_WITH_THROWS, image);
				resultingCollections.add(proposal);

					for (Type elementType : types) {
						if (!(elementType instanceof SimpleType || elementType instanceof NameQualifiedType))
							return false;
						addExceptionToThrows(methodDeclaration, rewrite, elementType);
					}
				} else {
					addExceptionToThrows(methodDeclaration, rewrite, type);
				}
				String label= CorrectionMessages.QuickAssistProcessor_catchclausetothrows_description;
				ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REPLACE_CATCH_CLAUSE_WITH_THROWS, image);

	}

	private static void removeException(ASTRewrite rewrite, UnionType unionType, Type exception) {
		DeclarationRewrite.removeTypeAnnotationsFromDeclaration(exception, rewrite, null);
		ListRewrite listRewrite= rewrite.getListRewrite(unionType, UnionType.TYPES_PROPERTY);
		List<Type> types= unionType.types();
		for (Iterator<Type> iterator= types.iterator(); iterator.hasNext();) {

		}
	}

	private static void addExceptionToThrows(MethodDeclaration methodDeclaration, ASTRewrite rewrite, Type type2) {
		ITypeBinding binding= type2.resolveBinding();
		if (binding == null || isNotYetThrown(binding, methodDeclaration.thrownExceptionTypes())) {
			Type newType= DeclarationRewrite.copyTypeAndAddTypeAnnotations(type2, rewrite);

			ListRewrite listRewriter= rewrite.getListRewrite(methodDeclaration, MethodDeclaration.THROWN_EXCEPTION_TYPES_PROPERTY);
			listRewriter.insertLast(newType, null);

		List<Type> types= newUnionType.types();
		for (int i= 0; i < coveredNodes.size(); i++) {
			ASTNode typeNode= coveredNodes.get(i);
			if (typeNode instanceof Type) {
				Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations((Type) typeNode, rewrite, null);				
				types.add(copiedTypeNode);
				rewrite.remove(typeNode, null);
			}
		}
		newSingleVariableDeclaration.setType(newUnionType);
		newSingleVariableDeclaration.setName((SimpleName) rewrite.createCopyTarget(catchClause.getException().getName()));

			if (type instanceof UnionType) {
				List<Type> types2= ((UnionType) type).types();
				for (Iterator<Type> iterator2= types2.iterator(); iterator2.hasNext();) {
					Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations(iterator2.next(), rewrite, null);
					types.add(copiedTypeNode);
				}
			} else {
				Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations(type, rewrite, null);
				types.add(copiedTypeNode);
			}
		}


			CatchClause newCatchClause= ast.newCatchClause();

			SingleVariableDeclaration newSingleVariableDeclaration= ast.newSingleVariableDeclaration();
			Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations(type2, rewrite, null);				
			newSingleVariableDeclaration.setType(copiedTypeNode);
			newSingleVariableDeclaration.setName((SimpleName) rewrite.createCopyTarget(singleVariableDeclaration.getName()));
			newCatchClause.setException(newSingleVariableDeclaration);
			setCatchClauseBody(newCatchClause, rewrite, catchClause);

				VariableDeclarationStatement varDeclaration= ast.newVariableDeclarationStatement(varFragment);
				Type varType;
				if (initializerIsArray) {
					Type copiedType= DimensionRewrite.copyTypeAndAddDimensions(parameter.getType(), parameter.extraDimensions(), rewrite);
					varType= ASTNodeFactory.newArrayType(copiedType);
					varType= varArrayType;
				} else {
					ImportRewrite imports= proposal.createImportRewrite(context.getASTRoot());
					ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(node, imports);

Return to bug 426967

Lines 121-126 Link Here

(-)a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java (-14 / +22 lines)
121	import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;	121	import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
122	import org.eclipse.jdt.internal.corext.dom.ASTNodes;	122	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
123	import org.eclipse.jdt.internal.corext.dom.Bindings;	123	import org.eclipse.jdt.internal.corext.dom.Bindings;
		124	import org.eclipse.jdt.internal.corext.dom.DeclarationRewrite;
124	import org.eclipse.jdt.internal.corext.dom.DimensionRewrite;	125	import org.eclipse.jdt.internal.corext.dom.DimensionRewrite;
125	import org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder;	126	import org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder;
126	import org.eclipse.jdt.internal.corext.dom.ModifierRewrite;	127	import org.eclipse.jdt.internal.corext.dom.ModifierRewrite;
Lines 951-957 Link Here
951	VariableDeclarationExpression oldVarDecl= (VariableDeclarationExpression) fragParent;	952	VariableDeclarationExpression oldVarDecl= (VariableDeclarationExpression) fragParent;
952		953
953	VariableDeclarationStatement newVarDec= ast.newVariableDeclarationStatement(newFrag);	954	VariableDeclarationStatement newVarDec= ast.newVariableDeclarationStatement(newFrag);
954	newVarDec.setType((Type) rewrite.createCopyTarget(oldVarDecl.getType()));	955	Type copiedTypeNode= DeclarationRewrite.copyTypeAndAddTypeAnnotations(oldVarDecl.getType(), rewrite);
		956	newVarDec.setType(copiedTypeNode);
955	newVarDec.modifiers().addAll(ASTNodeFactory.newModifiers(ast, oldVarDecl.getModifiers()));	957	newVarDec.modifiers().addAll(ASTNodeFactory.newModifiers(ast, oldVarDecl.getModifiers()));
956	newStatement= newVarDec;	958	newStatement= newVarDec;
957	}	959	}
Lines 1503-1509 Link Here
1503	ASTRewrite rewrite= ASTRewrite.create(ast);	1505	ASTRewrite rewrite= ASTRewrite.create(ast);
1504	if (selectedMultiCatchType != null) {	1506	if (selectedMultiCatchType != null) {
1505	removeException(rewrite, (UnionType) type, selectedMultiCatchType);	1507	removeException(rewrite, (UnionType) type, selectedMultiCatchType);
1506	addExceptionToThrows(ast, methodDeclaration, rewrite, selectedMultiCatchType);	1508	addExceptionToThrows(methodDeclaration, rewrite, selectedMultiCatchType);
1507	String label= CorrectionMessages.QuickAssistProcessor_exceptiontothrows_description;	1509	String label= CorrectionMessages.QuickAssistProcessor_exceptiontothrows_description;
1508	ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REPLACE_EXCEPTION_WITH_THROWS, image);	1510	ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REPLACE_EXCEPTION_WITH_THROWS, image);
1509	resultingCollections.add(proposal);	1511	resultingCollections.add(proposal);
Lines 1515-1524 Link Here
1515	for (Type elementType : types) {	1517	for (Type elementType : types) {
1516	if (!(elementType instanceof SimpleType \|\| elementType instanceof NameQualifiedType))	1518	if (!(elementType instanceof SimpleType \|\| elementType instanceof NameQualifiedType))
1517	return false;	1519	return false;
1518	addExceptionToThrows(ast, methodDeclaration, rewrite, elementType);	1520	addExceptionToThrows(methodDeclaration, rewrite, elementType);
1519	}	1521	}
1520	} else {	1522	} else {
1521	addExceptionToThrows(ast, methodDeclaration, rewrite, type);	1523	addExceptionToThrows(methodDeclaration, rewrite, type);
1522	}	1524	}
1523	String label= CorrectionMessages.QuickAssistProcessor_catchclausetothrows_description;	1525	String label= CorrectionMessages.QuickAssistProcessor_catchclausetothrows_description;
1524	ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REPLACE_CATCH_CLAUSE_WITH_THROWS, image);	1526	ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REPLACE_CATCH_CLAUSE_WITH_THROWS, image);
Lines 1544-1549 Link Here
1544	}	1546	}
1545		1547
1546	private static void removeException(ASTRewrite rewrite, UnionType unionType, Type exception) {	1548	private static void removeException(ASTRewrite rewrite, UnionType unionType, Type exception) {
		1549	DeclarationRewrite.removeTypeAnnotationsFromDeclaration(exception, rewrite, null);
1547	ListRewrite listRewrite= rewrite.getListRewrite(unionType, UnionType.TYPES_PROPERTY);	1550	ListRewrite listRewrite= rewrite.getListRewrite(unionType, UnionType.TYPES_PROPERTY);
1548	List<Type> types= unionType.types();	1551	List<Type> types= unionType.types();
1549	for (Iterator<Type> iterator= types.iterator(); iterator.hasNext();) {	1552	for (Iterator<Type> iterator= types.iterator(); iterator.hasNext();) {
Lines 1554-1563 Link Here
1554	}	1557	}
1555	}	1558	}
1556		1559
1557	private static void addExceptionToThrows(AST ast, MethodDeclaration methodDeclaration, ASTRewrite rewrite, Type type2) {	1560	private static void addExceptionToThrows(MethodDeclaration methodDeclaration, ASTRewrite rewrite, Type type2) {
1558	ITypeBinding binding= type2.resolveBinding();	1561	ITypeBinding binding= type2.resolveBinding();
1559	if (binding == null \|\| isNotYetThrown(binding, methodDeclaration.thrownExceptionTypes())) {	1562	if (binding == null \|\| isNotYetThrown(binding, methodDeclaration.thrownExceptionTypes())) {
1560	Type newType= (Type) ASTNode.copySubtree(ast, type2);	1563	Type newType= DeclarationRewrite.copyTypeAndAddTypeAnnotations(type2, rewrite);
1561		1564
1562	ListRewrite listRewriter= rewrite.getListRewrite(methodDeclaration, MethodDeclaration.THROWN_EXCEPTION_TYPES_PROPERTY);	1565	ListRewrite listRewriter= rewrite.getListRewrite(methodDeclaration, MethodDeclaration.THROWN_EXCEPTION_TYPES_PROPERTY);
1563	listRewriter.insertLast(newType, null);	1566	listRewriter.insertLast(newType, null);
Lines 1657-1664 Link Here
1657	List<Type> types= newUnionType.types();	1660	List<Type> types= newUnionType.types();
1658	for (int i= 0; i < coveredNodes.size(); i++) {	1661	for (int i= 0; i < coveredNodes.size(); i++) {
1659	ASTNode typeNode= coveredNodes.get(i);	1662	ASTNode typeNode= coveredNodes.get(i);
1660	types.add((Type) rewrite.createCopyTarget(typeNode));	1663	if (typeNode instanceof Type) {
1661	rewrite.remove(typeNode, null);	1664	Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations((Type) typeNode, rewrite, null);
		1665	types.add(copiedTypeNode);
		1666	rewrite.remove(typeNode, null);
		1667	}
1662	}	1668	}
1663	newSingleVariableDeclaration.setType(newUnionType);	1669	newSingleVariableDeclaration.setType(newUnionType);
1664	newSingleVariableDeclaration.setName((SimpleName) rewrite.createCopyTarget(catchClause.getException().getName()));	1670	newSingleVariableDeclaration.setName((SimpleName) rewrite.createCopyTarget(catchClause.getException().getName()));
Lines 1747-1756 Link Here
1747	if (type instanceof UnionType) {	1753	if (type instanceof UnionType) {
1748	List<Type> types2= ((UnionType) type).types();	1754	List<Type> types2= ((UnionType) type).types();
1749	for (Iterator<Type> iterator2= types2.iterator(); iterator2.hasNext();) {	1755	for (Iterator<Type> iterator2= types2.iterator(); iterator2.hasNext();) {
1750	types.add((Type) rewrite.createCopyTarget(iterator2.next()));	1756	Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations(iterator2.next(), rewrite, null);
		1757	types.add(copiedTypeNode);
1751	}	1758	}
1752	} else {	1759	} else {
1753	types.add((Type) rewrite.createCopyTarget(type));	1760	Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations(type, rewrite, null);
		1761	types.add(copiedTypeNode);
1754	}	1762	}
1755	}	1763	}
1756		1764
Lines 1817-1823 Link Here
1817	CatchClause newCatchClause= ast.newCatchClause();	1825	CatchClause newCatchClause= ast.newCatchClause();
1818		1826
1819	SingleVariableDeclaration newSingleVariableDeclaration= ast.newSingleVariableDeclaration();	1827	SingleVariableDeclaration newSingleVariableDeclaration= ast.newSingleVariableDeclaration();
1820	newSingleVariableDeclaration.setType((Type) rewrite.createCopyTarget(type2));	1828	Type copiedTypeNode= DeclarationRewrite.copyTypeAndMoveTypeAnnotations(type2, rewrite, null);
		1829	newSingleVariableDeclaration.setType(copiedTypeNode);
1821	newSingleVariableDeclaration.setName((SimpleName) rewrite.createCopyTarget(singleVariableDeclaration.getName()));	1830	newSingleVariableDeclaration.setName((SimpleName) rewrite.createCopyTarget(singleVariableDeclaration.getName()));
1822	newCatchClause.setException(newSingleVariableDeclaration);	1831	newCatchClause.setException(newSingleVariableDeclaration);
1823	setCatchClauseBody(newCatchClause, rewrite, catchClause);	1832	setCatchClauseBody(newCatchClause, rewrite, catchClause);
Lines 2585-2593 Link Here
2585	VariableDeclarationStatement varDeclaration= ast.newVariableDeclarationStatement(varFragment);	2594	VariableDeclarationStatement varDeclaration= ast.newVariableDeclarationStatement(varFragment);
2586	Type varType;	2595	Type varType;
2587	if (initializerIsArray) {	2596	if (initializerIsArray) {
2588	ArrayType varArrayType= (ArrayType) DimensionRewrite.copyTypeAndAddDimensions(parameter.getType(), parameter.extraDimensions(), rewrite);	2597	Type copiedType= DimensionRewrite.copyTypeAndAddDimensions(parameter.getType(), parameter.extraDimensions(), rewrite);
2589	varArrayType.dimensions().add(0, ast.newDimension());	2598	varType= ASTNodeFactory.newArrayType(copiedType);
2590	varType= varArrayType;
2591	} else {	2599	} else {
2592	ImportRewrite imports= proposal.createImportRewrite(context.getASTRoot());	2600	ImportRewrite imports= proposal.createImportRewrite(context.getASTRoot());
2593	ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(node, imports);	2601	ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(node, imports);

Added Link Here

(-)a/org.eclipse.jdt.ui/core (+170 lines)
1	/*******************************************************************************
2	* Copyright (c) 2014 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* This is an implementation of an early-draft specification developed under the Java
9	* Community Process (JCP) and is made available for testing and evaluation purposes
10	* only. The code is not compatible with any specification of the JCP.
11	*
12	* Contributors:
13	* IBM Corporation - initial API and implementation
14	*******************************************************************************/
15	package org.eclipse.jdt.internal.corext.dom;
16
17	import java.util.ArrayList;
18	import java.util.Arrays;
19	import java.util.Collections;
20	import java.util.List;
21
22	import org.eclipse.text.edits.TextEditGroup;
23
24	import org.eclipse.jdt.core.dom.ASTNode;
25	import org.eclipse.jdt.core.dom.AnnotatableType;
26	import org.eclipse.jdt.core.dom.Annotation;
27	import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
28	import org.eclipse.jdt.core.dom.ArrayType;
29	import org.eclipse.jdt.core.dom.FieldDeclaration;
30	import org.eclipse.jdt.core.dom.IAnnotationBinding;
31	import org.eclipse.jdt.core.dom.IExtendedModifier;
32	import org.eclipse.jdt.core.dom.ITypeBinding;
33	import org.eclipse.jdt.core.dom.MethodDeclaration;
34	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
35	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
36	import org.eclipse.jdt.core.dom.Type;
37	import org.eclipse.jdt.core.dom.UnionType;
38	import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
39	import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
40	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
41
42	import org.eclipse.jdt.internal.corext.util.JDTUIHelperClasses;
43
44	/**
45	* Rewrite helper for type annotations part of the declaration's modifiers of a type reference.
46	*
47	* @see JDTUIHelperClasses
48	* @since 3.9 BETA_JAVA8
49	*/
50	public class DeclarationRewrite {
51
52	/**
53	* Creates a copy of the given <code>typeNode</code> and adds its type annotations to the copied
54	* type by removing them from its declaration's modifiers.
55	*
56	* @param typeNode the Type node
57	* @param rewrite the ASTRewrite with which to create new nodes
58	* @param editGroup the edit group in which to collect the corresponding text edits, or null if
59	* ungrouped
60	* @return copy of the type node with added type annotations
61	*/
62	public static Type copyTypeAndMoveTypeAnnotations(Type typeNode, ASTRewrite rewrite, TextEditGroup editGroup) {
63	Type copiedtypeNode= copyTypeAndAddTypeAnnotations(typeNode, rewrite);
64	removeTypeAnnotationsFromDeclaration(typeNode, rewrite, editGroup);
65	return copiedtypeNode;
66	}
67
68	/**
69	* Creates a copy of the given <code>typeNode</code> and adds its type annotations to the copied
70	* type by copying them from its declaration's modifiers. The type annotations are not removed
71	* from the declaration node.
72	*
73	* @param typeNode the Type node
74	* @param rewrite the ASTRewrite with which to create new nodes
75	* @return copy of the type node with added type annotations
76	*/
77	public static Type copyTypeAndAddTypeAnnotations(Type typeNode, ASTRewrite rewrite) {
78	if (!(typeNode instanceof AnnotatableType \|\| (typeNode instanceof ArrayType && ((ArrayType) typeNode).getElementType() instanceof AnnotatableType)))
79	return (Type) rewrite.createCopyTarget(typeNode);
80
81	List<Annotation> typeAnnotations= DeclarationRewrite.getTypeAnnotationsOnDeclaration(typeNode);
82	if (typeAnnotations.isEmpty())
83	return (Type) rewrite.createCopyTarget(typeNode);
84
85	Type copiedTypeNode= (Type) ASTNode.copySubtree(rewrite.getAST(), typeNode);
86	AnnotatableType copiedAnnotatableType;
87	if (copiedTypeNode instanceof ArrayType) {
88	copiedAnnotatableType= (AnnotatableType) ((ArrayType) copiedTypeNode).getElementType();
89	} else {
90	copiedAnnotatableType= (AnnotatableType) copiedTypeNode;
91	}
92	for (Annotation annotation : typeAnnotations) {
93	copiedAnnotatableType.annotations().add(rewrite.createCopyTarget(annotation));
94	}
95	return copiedTypeNode;
96	}
97
98	/**
99	* Removes type annotations of the given <code>typeNode</code> from its declaration's modifiers.
100	*
101	* @param typeNode the Type node
102	* @param rewrite rewrite that removes the nodes
103	* @param editGroup the edit group in which to collect the corresponding text edits, or null if
104	* ungrouped
105	*/
106	public static void removeTypeAnnotationsFromDeclaration(Type typeNode, ASTRewrite rewrite, TextEditGroup editGroup) {
107	List<Annotation> typeAnnotations= DeclarationRewrite.getTypeAnnotationsOnDeclaration(typeNode);
108	for (Annotation annotation : typeAnnotations) {
109	rewrite.remove(annotation, editGroup);
110	}
111	}
112
113	private static List<Annotation> getTypeAnnotationsOnDeclaration(Type typeNode) {
114	ITypeBinding typeBinding= typeNode.resolveBinding();
115	if (typeBinding == null)
116	return Collections.emptyList();
117
118	List<IAnnotationBinding> typeAnnotationBindings;
119	if (typeBinding.isArray()) {
120	typeAnnotationBindings= Arrays.asList(typeBinding.getElementType().getTypeAnnotations());
121	} else {
122	typeAnnotationBindings= Arrays.asList(typeBinding.getTypeAnnotations());
123	}
124
125	if (typeAnnotationBindings.size() == 0)
126	return Collections.emptyList();
127
128	List<IExtendedModifier> declarationModifiers= new ArrayList<IExtendedModifier>();
129	StructuralPropertyDescriptor locationInParent= typeNode.getLocationInParent();
130
131	if (locationInParent == UnionType.TYPES_PROPERTY) {
132	typeNode= (UnionType) typeNode.getParent();
133	locationInParent= typeNode.getLocationInParent();
134	}
135
136	if (locationInParent == ArrayType.ELEMENT_TYPE_PROPERTY) {
137	typeNode= (ArrayType) typeNode.getParent();
138	locationInParent= typeNode.getLocationInParent();
139	}
140
141	if (locationInParent == MethodDeclaration.RETURN_TYPE2_PROPERTY) {
142	declarationModifiers= ((MethodDeclaration) typeNode.getParent()).modifiers();
143	} else if (locationInParent == FieldDeclaration.TYPE_PROPERTY) {
144	declarationModifiers= ((FieldDeclaration) typeNode.getParent()).modifiers();
145	} else if (locationInParent == VariableDeclarationExpression.TYPE_PROPERTY) {
146	declarationModifiers= ((VariableDeclarationExpression) typeNode.getParent()).modifiers();
147	} else if (locationInParent == VariableDeclarationStatement.TYPE_PROPERTY) {
148	declarationModifiers= ((VariableDeclarationStatement) typeNode.getParent()).modifiers();
149	} else if (locationInParent == SingleVariableDeclaration.TYPE_PROPERTY) {
150	declarationModifiers= ((SingleVariableDeclaration) typeNode.getParent()).modifiers();
151	} else if (locationInParent == AnnotationTypeMemberDeclaration.TYPE_PROPERTY) {
152	declarationModifiers= ((AnnotationTypeMemberDeclaration) typeNode.getParent()).modifiers();
153	}
154
155	return getTypeAnnotationsFromModifiers(declarationModifiers, typeAnnotationBindings);
156	}
157
158	private static List<Annotation> getTypeAnnotationsFromModifiers(List<IExtendedModifier> modifiers, List<IAnnotationBinding> typeAnnotationBindings) {
159	List<Annotation> typeAnnotations= new ArrayList<Annotation>();
160	for (IExtendedModifier modifier : modifiers) {
161	if (modifier.isAnnotation()) {
162	IAnnotationBinding modifierAnnotationBinding= ((Annotation) modifier).resolveAnnotationBinding();
163	if (typeAnnotationBindings.contains(modifierAnnotationBinding)) {
164	typeAnnotations.add((Annotation) modifier);
165	}
166	}
167	}
168	return typeAnnotations;
169	}
170	}

Lines 81-86 Link Here

(-)a/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/PromoteTempToFieldRefactoring.java (-1 / +2 lines)
81	import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;	81	import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
82	import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;	82	import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
83	import org.eclipse.jdt.internal.corext.dom.ASTNodes;	83	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
		84	import org.eclipse.jdt.internal.corext.dom.DeclarationRewrite;
84	import org.eclipse.jdt.internal.corext.dom.DimensionRewrite;	85	import org.eclipse.jdt.internal.corext.dom.DimensionRewrite;
85	import org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor;	86	import org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor;
86	import org.eclipse.jdt.internal.corext.dom.ModifierRewrite;	87	import org.eclipse.jdt.internal.corext.dom.ModifierRewrite;
Lines 862-868 Link Here
862	FieldDeclaration fieldDeclaration= ast.newFieldDeclaration(fragment);	863	FieldDeclaration fieldDeclaration= ast.newFieldDeclaration(fragment);
863		864
864	VariableDeclarationStatement vds= getTempDeclarationStatement();	865	VariableDeclarationStatement vds= getTempDeclarationStatement();
865	Type type= (Type)rewrite.createCopyTarget(vds.getType());	866	Type type= DeclarationRewrite.copyTypeAndAddTypeAnnotations(vds.getType(), rewrite);
866	fieldDeclaration.setType(type);	867	fieldDeclaration.setType(type);
867	fieldDeclaration.modifiers().addAll(ASTNodeFactory.newModifiers(ast, getModifiers()));	868	fieldDeclaration.modifiers().addAll(ASTNodeFactory.newModifiers(ast, getModifiers()));
868	return fieldDeclaration;	869	return fieldDeclaration;