| /******************************************************************************* |
| * Copyright (c) 2009 SpringSource and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Andrew Eisenberg - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.ajdt.internal.ui.refactoring; |
| |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| |
| import org.aspectj.asm.IProgramElement; |
| import org.aspectj.asm.IProgramElement.Kind; |
| import org.eclipse.ajdt.core.AspectJCore; |
| import org.eclipse.ajdt.core.codeconversion.AspectsConvertingParser; |
| import org.eclipse.ajdt.core.javaelements.AJCompilationUnit; |
| import org.eclipse.ajdt.core.javaelements.DeclareElement; |
| import org.eclipse.ajdt.core.javaelements.DeclareElementInfo; |
| import org.eclipse.ajdt.core.javaelements.IAspectJElement; |
| import org.eclipse.ajdt.core.javaelements.IntertypeElement; |
| import org.eclipse.ajdt.core.model.AJProjectModelFacade; |
| import org.eclipse.ajdt.core.model.AJProjectModelFactory; |
| import org.eclipse.ajdt.core.model.AJRelationshipManager; |
| import org.eclipse.ajdt.core.model.AJRelationshipType; |
| import org.eclipse.ajdt.ui.AspectJUIPlugin; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.jdt.core.IAnnotatable; |
| import org.eclipse.jdt.core.IAnnotation; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IMember; |
| import org.eclipse.jdt.core.ISourceRange; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.dom.AST; |
| 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.AbstractTypeDeclaration; |
| import org.eclipse.jdt.core.dom.BodyDeclaration; |
| import org.eclipse.jdt.core.dom.CompilationUnit; |
| import org.eclipse.jdt.core.dom.FieldDeclaration; |
| import org.eclipse.jdt.core.dom.ITypeBinding; |
| import org.eclipse.jdt.core.dom.Name; |
| import org.eclipse.jdt.core.dom.SimpleName; |
| import org.eclipse.jdt.core.dom.SimpleType; |
| import org.eclipse.jdt.core.dom.Type; |
| import org.eclipse.jdt.core.dom.TypeDeclaration; |
| import org.eclipse.jdt.core.dom.VariableDeclarationFragment; |
| import org.eclipse.jdt.core.dom.rewrite.ASTRewrite; |
| import org.eclipse.jdt.core.dom.rewrite.ImportRewrite; |
| import org.eclipse.jdt.core.dom.rewrite.ListRewrite; |
| import org.eclipse.jdt.core.manipulation.ImportReferencesCollector; |
| import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner; |
| import org.eclipse.jdt.internal.core.JavaProject; |
| import org.eclipse.jdt.internal.core.NameLookup; |
| import org.eclipse.jdt.internal.core.NameLookup.Answer; |
| import org.eclipse.jface.text.Region; |
| import org.eclipse.ltk.core.refactoring.Change; |
| import org.eclipse.ltk.core.refactoring.ChangeDescriptor; |
| import org.eclipse.ltk.core.refactoring.CompositeChange; |
| import org.eclipse.ltk.core.refactoring.Refactoring; |
| import org.eclipse.ltk.core.refactoring.RefactoringChangeDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.TextFileChange; |
| import org.eclipse.ltk.core.refactoring.resource.DeleteResourceChange; |
| import org.eclipse.text.edits.DeleteEdit; |
| import org.eclipse.text.edits.InsertEdit; |
| import org.eclipse.text.edits.MultiTextEdit; |
| import org.eclipse.text.edits.TextEdit; |
| |
| /** |
| * @author Andrew Eisenberg |
| * @author Andy Clement |
| */ |
| public class PushInRefactoring extends Refactoring { |
| |
| public static final String ALL_ITDS = "all.itds"; |
| public static final String DELETE_EMPTY = "delete.empty"; |
| |
| /** |
| * Since each class is visited multiple times, and each visit may introduce |
| * new imports, we must delay import rewriting |
| * until each class has its ITDs already pushed in. |
| * |
| */ |
| private class PerUnitInformation { |
| final Set<SimpleName> staticImports; |
| final Set<SimpleName> typeImports; |
| final Set<String> extraImports; |
| final ICompilationUnit unit; |
| |
| // all declare parents (extends) to insert |
| final Map<IType, Set<String>> declareParents; |
| |
| PerUnitInformation(ICompilationUnit unit) { |
| staticImports = new HashSet<SimpleName>(); |
| typeImports = new HashSet<SimpleName>(); |
| extraImports = new HashSet<String>(); |
| this.unit = unit; |
| declareParents = new HashMap<IType, Set<String>>(); |
| } |
| |
| // does not handle imports for declare parents |
| void rewriteImports() throws CoreException { |
| // first check to see if this unit has been deleted. |
| Change change = allChanges.get(unit); |
| if (! (change instanceof TextFileChange)) { |
| return; |
| } |
| |
| ImportRewrite rewrite = ImportRewrite.create(unit, true); |
| for (Name name : typeImports) { |
| ITypeBinding binding = name.resolveTypeBinding(); |
| if (binding != null) { |
| rewrite.addImport(binding); |
| } |
| } |
| for (Name name : staticImports) { |
| ITypeBinding binding = name.resolveTypeBinding(); |
| if (binding != null) { |
| rewrite.addImport(name.resolveTypeBinding()); |
| } |
| } |
| |
| for (String qualName : extraImports) { |
| rewrite.addImport(qualName); |
| } |
| TextEdit importEdit = rewrite.rewriteImports(new NullProgressMonitor()); |
| |
| TextFileChange textChange = (TextFileChange) change; |
| textChange.getEdit().addChild(importEdit); |
| } |
| |
| void computeImports(List<IMember> itds, ICompilationUnit ajUnit, IProgressMonitor monitor) |
| throws JavaModelException { |
| IJavaProject project = ajUnit.getJavaProject(); |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setProject(project); |
| parser.setResolveBindings(true); |
| parser.setSource(ajUnit); |
| parser.setKind(ASTParser.K_COMPILATION_UNIT); |
| CompilationUnit ajAST = (CompilationUnit) parser.createAST(monitor); |
| |
| for (IMember itd : itds) { |
| ISourceRange range = itd.getSourceRange(); |
| ImportReferencesCollector.collect(ajAST, project, new Region( |
| range.getOffset(), range.getLength()), |
| typeImports, staticImports); |
| if (itd instanceof DeclareElement) { |
| DeclareElement declare = (DeclareElement) itd; |
| // no types added for declare removers |
| if (!((DeclareElementInfo) declare.getElementInfo()).isAnnotationRemover()) { |
| String qualType = getQualifiedTypeForDeclareAnnotation(declare); |
| if (qualType != null && qualType.length() > 0) { |
| extraImports.add(qualType); |
| } |
| List<Type> types = getExtraImportsFromDeclareElement(declare, ajAST); |
| for (Type type : types) { |
| ImportReferencesCollector.collect(type, project, new Region( |
| type.getStartPosition(), type.getLength()), |
| typeImports, staticImports); |
| } |
| } |
| } |
| } |
| } |
| |
| // This method finds the extra imports required by a declare element |
| // (eg- used inside of a declare @annotation's annotation) |
| // We take advantage of the format of the converted source from aspectj to java |
| // the last fields of the last type when following a particular naming convention, |
| // are around to force import statements to exist. We can read them and use them |
| // to seed the extra imports list |
| private List<Type> getExtraImportsFromDeclareElement(DeclareElement itd, |
| CompilationUnit ajAST) { |
| int numTypes = ajAST.types().size(); |
| if (numTypes == 0) { |
| return Collections.emptyList(); |
| } |
| |
| String details = null; |
| AbstractTypeDeclaration lastType = (AbstractTypeDeclaration) ajAST.types().get(numTypes-1); |
| @SuppressWarnings("unchecked") |
| List<BodyDeclaration> bodyDecls = lastType.bodyDeclarations(); |
| List<Type> extraSimpleNames = new LinkedList<Type>(); |
| for (int i = bodyDecls.size()-1; i >= 0; i--) { |
| BodyDeclaration decl = bodyDecls.get(i); |
| if (decl.getNodeType() == ASTNode.FIELD_DECLARATION) { |
| FieldDeclaration fDecl = (FieldDeclaration) decl; |
| if (fDecl.fragments().size() == 1) { |
| VariableDeclarationFragment frag = (VariableDeclarationFragment) fDecl.fragments().get(0); |
| if (frag.getName().toString().startsWith(AspectsConvertingParser.ITD_INSERTED_IDENTIFIER)) { |
| if (details == null) { |
| IProgramElement ipe = getModel(itd).javaElementToProgramElement(itd); |
| details = ipe.getDetails(); |
| } |
| Type type = fDecl.getType(); |
| // only add if this type exists in the declare @annotation |
| if (details.indexOf(type.toString()) != -1) { |
| extraSimpleNames.add(type); |
| } |
| |
| continue; |
| } |
| } |
| } |
| // break on the first body declaration that does not conform |
| break; |
| } |
| return extraSimpleNames; |
| } |
| |
| public void addDeclarParents(IType type, List<String> parentTypes) { |
| Set<String> set = declareParents.get(type); |
| if (set == null) { |
| set = new LinkedHashSet<String>(); |
| declareParents.put(type, set); |
| } |
| set.addAll(parentTypes); |
| for (String parent : parentTypes) { |
| String[] split = parent.split("<|>|,"); |
| for (String name : split) { |
| extraImports.add(name.trim()); |
| } |
| } |
| } |
| } |
| |
| private boolean deleteEmpty = true; |
| |
| private Map<ICompilationUnit, Change> allChanges = null; |
| |
| private List<IMember> itds = null; |
| |
| private Map<IProject, AJProjectModelFacade> allModels = new HashMap<IProject, AJProjectModelFacade>(); |
| private AJProjectModelFacade getModel(IJavaElement elt) { |
| IProject project = elt.getJavaProject().getProject(); |
| AJProjectModelFacade model = allModels.get(project); |
| if (model == null) { |
| model = AJProjectModelFactory.getInstance().getModelForProject(project); |
| allModels.put(project, model); |
| } |
| return model; |
| } |
| |
| private Map<IJavaProject, NameLookup> allLookups = new HashMap<IJavaProject, NameLookup>(); |
| private NameLookup getLookup(IJavaElement elt) throws JavaModelException { |
| IJavaProject javaProject = elt.getJavaProject(); |
| NameLookup nameLookup = allLookups.get(javaProject); |
| if (nameLookup == null) { |
| nameLookup = ((JavaProject) javaProject).newNameLookup(DefaultWorkingCopyOwner.PRIMARY); |
| allLookups.put(javaProject, nameLookup); |
| } |
| return nameLookup; |
| } |
| |
| |
| @Override |
| public RefactoringStatus checkFinalConditions(IProgressMonitor monitor) |
| throws CoreException, OperationCanceledException { |
| final RefactoringStatus status = new RefactoringStatus(); |
| try { |
| monitor.beginTask("Checking final conditions...", 2); |
| allChanges = new LinkedHashMap<ICompilationUnit, Change>(); |
| // map from AJCUs to contained ITDs that will be pushed in |
| Map<ICompilationUnit, List<IMember>> unitToITDs = new HashMap<ICompilationUnit, List<IMember>>(); |
| Map<ICompilationUnit, PerUnitInformation> importsMap = new HashMap<ICompilationUnit, PerUnitInformation>(); |
| |
| for (IMember itd : itds) { |
| if (itd instanceof IAspectJElement && ((IAspectJElement) itd).getAJKind() == Kind.DECLARE_PARENTS) { |
| AJProjectModelFacade model = getModel(itd); |
| // rememebr the types pushed in and associate them with the target types |
| List<IJavaElement> elts = model.getRelationshipsForElement(itd, AJRelationshipManager.DECLARED_ON); |
| IProgramElement ipe = model.javaElementToProgramElement(itd); |
| List<String> parentTypes = ipe.getParentTypes(); |
| for (IJavaElement elt : elts) { |
| if (elt.getElementType() == IJavaElement.TYPE) { |
| IType type = (IType) elt; |
| ICompilationUnit owningUnit = type.getCompilationUnit(); |
| PerUnitInformation holder = importsMap.get(owningUnit); |
| if (holder == null) { |
| holder = new PerUnitInformation(owningUnit); |
| importsMap.put(owningUnit, holder); |
| } |
| holder.addDeclarParents(type, parentTypes); |
| } |
| } |
| } |
| |
| // remember the ITDs per compilation unit so that we can remove them later |
| ICompilationUnit unit = itd.getCompilationUnit(); |
| List<IMember> itdList = unitToITDs.get(unit); |
| if (itdList == null) { |
| itdList = new LinkedList<IMember>(); |
| unitToITDs.put(unit, itdList); |
| } |
| itdList.add(itd); |
| } |
| |
| // now do the work ITDs and declare annotation |
| for (Map.Entry<ICompilationUnit,List<IMember>> entry : unitToITDs.entrySet()) { |
| status.merge(checkFinalConditionsForITD( |
| entry.getKey(), entry.getValue(), importsMap, |
| monitor)); |
| } |
| |
| // now go through and create the import edits |
| for (PerUnitInformation holder : importsMap.values()) { |
| holder.rewriteImports(); |
| } |
| |
| } finally { |
| allLookups.clear(); |
| allModels.clear(); |
| monitor.done(); |
| } |
| return status; |
| } |
| |
| /** |
| * Checks the conditions for a single {@link AJCompilationUnit} |
| * @param ajUnit the unit to check |
| * @param itdsForUnit all itds in this unit |
| * @param imports a map from target {@link ICompilationUnit} to imports that need to be added |
| * initially empty, but populated in this method |
| * @param monitor |
| * @return |
| * @throws JavaModelException |
| */ |
| private RefactoringStatus checkFinalConditionsForITD(final ICompilationUnit ajUnit, |
| final List<IMember> itdsForUnit, |
| final Map<ICompilationUnit, PerUnitInformation> imports, |
| final IProgressMonitor monitor) throws JavaModelException { |
| |
| final RefactoringStatus status = new RefactoringStatus(); |
| |
| // group all of the ITD targets by the ICompilationUnit that they are in |
| final Map<ICompilationUnit, Set<IMember>> unitsToTypes = getUnitTypeMap(getTargets(itdsForUnit)); |
| |
| // group all of the ICompilationUnits by project |
| final Map<IJavaProject, Collection<ICompilationUnit>> projects= new HashMap<IJavaProject, Collection<ICompilationUnit>>(); |
| for (ICompilationUnit targetUnit : unitsToTypes.keySet()) { |
| IJavaProject project= targetUnit.getJavaProject(); |
| if (project != null) { |
| Collection<ICompilationUnit> collection = projects.get(project); |
| if (collection == null) { |
| collection= new ArrayList<ICompilationUnit>(); |
| projects.put(project, collection); |
| } |
| collection.add(targetUnit); |
| } |
| } |
| |
| // also add the ajunit to the collection of affected units |
| Collection<ICompilationUnit> units; |
| IJavaProject aspectProject = ajUnit.getJavaProject(); |
| if (projects.containsKey(aspectProject)) { |
| units = projects.get(aspectProject); |
| } else { |
| units = new ArrayList<ICompilationUnit>(); |
| projects.put(aspectProject, units); |
| } |
| units.add(ajUnit); |
| |
| // this requestor performs the real work |
| ASTRequestor requestors = new ASTRequestor() { |
| @Override |
| public void acceptAST(ICompilationUnit source, CompilationUnit ast) { |
| try { |
| |
| // compute the imports that this itd adds to this unit |
| PerUnitInformation holder; |
| if (imports.containsKey(source)) { |
| holder = imports.get(source); |
| } else { |
| holder = new PerUnitInformation(source); |
| imports.put(source, holder); |
| } |
| holder.computeImports(itdsForUnit, ajUnit, monitor); |
| |
| for (Entry<IType, Set<String>> entry : holder.declareParents.entrySet()) { |
| rewriteDeclareParents(entry.getKey(), ast, entry.getValue(), source); |
| } |
| |
| // make the simplifying assumption that the CU that contains the |
| // ITD does not also contain a target type |
| // Bug 310020 |
| if (isCUnitContainingITD(source, itdsForUnit.get(0))) { |
| // this is an AJCU. |
| rewriteAspectType(itdsForUnit, source, ast); |
| } else { |
| // this is a regular CU |
| |
| for (IMember itd : itdsForUnit) { |
| |
| // filter out the types not affected by itd |
| Collection<IMember> members = new ArrayList<IMember>(); |
| members.addAll(unitsToTypes.get(source)); |
| AJProjectModelFacade model = getModel(itd); |
| List<IJavaElement> realTargets; |
| if (itd instanceof IAspectJElement && ((IAspectJElement) itd).getAJKind().isDeclareAnnotation()) { |
| realTargets = model |
| .getRelationshipsForElement( |
| itd, |
| AJRelationshipManager.ANNOTATES); |
| } else { |
| // regular ITD or an ITIT |
| realTargets = model |
| .getRelationshipsForElement( |
| itd, |
| AJRelationshipManager.DECLARED_ON); |
| } |
| for (Iterator<IMember> memberIter = members.iterator(); memberIter |
| .hasNext();) { |
| IMember member = memberIter.next(); |
| if (!realTargets.contains(member)) { |
| memberIter.remove(); |
| } |
| } |
| |
| if (members.size() > 0) { |
| // if declare parents, store until later |
| if (itd instanceof IAspectJElement && |
| ((IAspectJElement) itd).getAJKind() == Kind.DECLARE_PARENTS) { |
| // already taken care of |
| } |
| applyTargetTypeEdits(itd, source, members); |
| } |
| } // for (Iterator itdIter = itdsForUnit.iterator(); itdIter.hasNext();) { |
| } |
| } catch (JavaModelException e) { |
| } catch (CoreException e) { |
| } |
| } |
| }; |
| IProgressMonitor subMonitor= new SubProgressMonitor(monitor, 1); |
| try { |
| try { |
| final Set<IJavaProject> set= projects.keySet(); |
| subMonitor.beginTask("Compiling source...", set.size()); |
| for (IJavaProject project : projects.keySet()) { |
| ASTParser parser= ASTParser.newParser(AST.JLS8); |
| parser.setProject(project); |
| parser.setResolveBindings(true); |
| Collection<ICompilationUnit> collection= projects.get(project); |
| parser.createASTs(collection.toArray( |
| new ICompilationUnit[collection.size()]), new String[0], |
| requestors, new SubProgressMonitor(subMonitor, 1)); |
| } |
| |
| } finally { |
| subMonitor.done(); |
| } |
| |
| } finally { |
| subMonitor.done(); |
| } |
| return status; |
| } |
| |
| |
| /** |
| * Removes all ITDs in the given compilation unit. |
| * Will delete an aspect if it has no more members. |
| * Will delete an {@link AJCompilationUnit} if all |
| * of its types are deleted. |
| * @param itdsForUnit the ITDs for the given unit |
| * @param source |
| * @param ast used to calculate imports |
| * @throws JavaModelException |
| * @throws CoreException |
| */ |
| protected void rewriteAspectType(List<IMember> itdsForUnit, |
| ICompilationUnit source, CompilationUnit ast) throws JavaModelException, CoreException { |
| |
| // used to keep track of aspect types that are deleted. |
| Map<IType, Integer> removalStored = new HashMap<IType, Integer>(); |
| Map<IType, List<DeleteEdit>> typeDeletes = new HashMap<IType, List<DeleteEdit>>(); |
| |
| // go through each ITD and create a delete edit for it |
| for (IMember itd : itdsForUnit) { |
| IType parentAspectType = (IType) itd.getParent(); |
| int numRemovals; |
| if (removalStored.containsKey(parentAspectType)) { |
| numRemovals = removalStored.get(parentAspectType).intValue(); |
| removalStored.put(parentAspectType, new Integer(++numRemovals)); |
| } else { |
| removalStored.put(parentAspectType, new Integer(1)); |
| } |
| List<DeleteEdit> deletes; |
| if (typeDeletes.containsKey(parentAspectType)) { |
| deletes = typeDeletes.get(parentAspectType); |
| } else { |
| deletes = new LinkedList<DeleteEdit>(); |
| typeDeletes.put(parentAspectType, deletes); |
| } |
| |
| DeleteEdit edit = new DeleteEdit(itd.getSourceRange().getOffset(), itd.getSourceRange().getLength()+1); |
| deletes.add(edit); |
| } |
| |
| if (deleteTypes(ast, typeDeletes, removalStored)) { |
| allChanges.put(source, new DeleteResourceChange(source.getResource().getFullPath(), false)); |
| } else { |
| applyAspectEdits(source, typeDeletes); |
| } |
| } |
| |
| /** |
| * Adds the specified new parents to the type. |
| * Need to determine if the new paretns are extends or implements |
| * |
| * FIXADE will not handle generic types |
| * @param targetType |
| * @param astUnit |
| * @param newParents |
| * @param holder |
| * @throws JavaModelException |
| */ |
| @SuppressWarnings("unchecked") |
| private void rewriteDeclareParents(IType targetType, CompilationUnit astUnit, Set<String> newParents, |
| ICompilationUnit unit) throws JavaModelException { |
| |
| // find the Type declaration in the ast |
| TypeDeclaration typeDecl = findType(astUnit, targetType.getElementName()); |
| if (typeDecl == null) { |
| createJavaModelException("Couldn't find type " + targetType.getElementName() + " in " + |
| unit.getElementName()); |
| } |
| |
| // convert all parents to simple names |
| List<String> simpleParents = new ArrayList<String>(newParents.size()); |
| for (String qual : newParents) { |
| simpleParents.add(convertToSimple(qual)); |
| } |
| |
| // now remove any possible duplicates |
| Type superclassType = typeDecl.getSuperclassType(); |
| Type supr = superclassType; |
| if (supr != null && supr.isSimpleType()) { |
| simpleParents.remove(((SimpleType) supr).getName().getFullyQualifiedName()); |
| } |
| for (Type iface : (Iterable<Type>) typeDecl.superInterfaceTypes()) { |
| if (iface.isSimpleType()) { |
| simpleParents.remove(((SimpleType) iface).getName().getFullyQualifiedName()); |
| } |
| } |
| |
| // Find the super class if exists |
| // make assumption that there is at most one super class defined. |
| // if this weren't the case, then there would be a compile error |
| // and it would not be possible to invoke refactoring |
| String newSuper = null; |
| for (String parent : newParents) { |
| if (isClass(parent, targetType)) { |
| newSuper = convertToSimple(parent); |
| simpleParents.remove(newSuper); |
| } |
| } |
| |
| // do the rewrite. Only need to add simple names since imports are already taken care of |
| // in the holder |
| ASTRewrite rewriter = ASTRewrite.create(astUnit.getAST()); |
| AST ast = typeDecl.getAST(); |
| if (newSuper != null) { |
| Type newSuperType = createTypeAST(newSuper, ast); |
| if (superclassType == null) { |
| rewriter.set(typeDecl, TypeDeclaration.SUPERCLASS_TYPE_PROPERTY, newSuperType, null); |
| } else { |
| rewriter.replace(superclassType, newSuperType, null); |
| } |
| } |
| if (simpleParents.size() > 0) { |
| ListRewrite listRewrite = rewriter.getListRewrite(typeDecl, TypeDeclaration.SUPER_INTERFACE_TYPES_PROPERTY); |
| for (String simpleParent : simpleParents) { |
| listRewrite.insertLast(createTypeAST(simpleParent, ast), null); |
| } |
| } |
| // finally, add the new change |
| TextEdit edit = rewriter.rewriteAST(); |
| if (!isEmptyEdit(edit)) { |
| TextFileChange change= (TextFileChange) allChanges.get(unit); |
| if (change == null) { |
| change= new TextFileChange(unit.getElementName(), (IFile) unit.getResource()); |
| change.setTextType("java"); |
| change.setEdit(new MultiTextEdit()); |
| allChanges.put(unit, change); |
| } |
| change.getEdit().addChild(edit); |
| } |
| } |
| |
| |
| private Type createTypeAST(String newSuper, AST ast) { |
| String toParse = newSuper + " t;"; |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setSource((toParse).toCharArray()); |
| parser.setKind(ASTParser.K_CLASS_BODY_DECLARATIONS); |
| ASTNode astNode = parser.createAST(null); |
| Type t = null; |
| if (astNode instanceof TypeDeclaration) { |
| Object object = ((TypeDeclaration) astNode).bodyDeclarations().get(0); |
| if (object instanceof FieldDeclaration) { |
| t = ((FieldDeclaration) object).getType(); |
| t = (Type) ASTNode.copySubtree(ast, t); |
| } |
| } |
| if (t == null) { |
| t = ast.newSimpleType(ast.newSimpleName("MISSING")); |
| } |
| return t; |
| } |
| |
| /** |
| * Converts from a possibly generic fully qualified type name to a simple fully |
| * qualified type name |
| * @param qualName |
| * @return |
| */ |
| String convertToSimple(String qualName) { |
| char[] charArray = qualName.toCharArray(); |
| StringBuilder candidate = new StringBuilder(charArray.length); |
| StringBuilder complete = new StringBuilder(charArray.length); |
| for (char c : charArray) { |
| switch (c) { |
| case '.': |
| candidate.delete(0, candidate.length()); |
| break; |
| case '<': |
| case ',': |
| case '>': |
| complete.append(candidate).append(c); |
| candidate.delete(0, candidate.length()); |
| break; |
| default: |
| candidate.append(c); |
| } |
| } |
| complete.append(candidate); |
| return complete.toString(); |
| } |
| |
| |
| /** |
| * @return true iff name is the fully qualified name of a class, false if an interface, enum, etc |
| * @throws JavaModelException |
| */ |
| private boolean isClass(String name, IType type) throws JavaModelException { |
| String erasedName = name; |
| int genericsIndex = name.indexOf('<'); |
| if (genericsIndex > 0) { |
| erasedName = name.substring(0, genericsIndex); |
| } |
| |
| int dotIndex = erasedName.lastIndexOf('.'); |
| String packageName; |
| String simpleName; |
| if (dotIndex > 0) { |
| packageName = erasedName.substring(0, dotIndex); |
| simpleName = erasedName.substring(dotIndex +1); |
| } else { |
| packageName = ""; |
| simpleName = erasedName; |
| } |
| IType found = findType(packageName, simpleName, type); |
| return found != null && found.isClass(); |
| } |
| private IType findType(String packageName, String simpleName, IType type) throws JavaModelException { |
| NameLookup lookup = getLookup(type); |
| Answer answer = lookup.findType(simpleName, packageName, false, NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES, true, false, false, null); |
| if (answer != null) { |
| return answer.type; |
| } |
| // might be an inner type |
| int dotIndex = packageName.lastIndexOf('.'); |
| if (dotIndex > 0) { |
| IType foundType = findType(packageName.substring(0, dotIndex), packageName.substring(dotIndex+1), type); |
| if (foundType != null && foundType.getType(simpleName).exists()) { |
| return foundType.getType(simpleName); |
| } |
| } |
| return null; |
| } |
| |
| |
| private void createJavaModelException(String message) |
| throws JavaModelException { |
| throw new JavaModelException(new CoreException(new Status(IStatus.INFO, AspectJUIPlugin.PLUGIN_ID, |
| message))); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private TypeDeclaration findType(CompilationUnit ast, String name) { |
| for (TypeDeclaration type : (Iterable<TypeDeclaration>) ast.types()) { |
| if (type.getName().getIdentifier().equals(name)) { |
| return type; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Deletes all aspect types that have no more children |
| * returns true if the compilation unit should be deleted |
| * @param ast |
| * @param typeDeletes |
| * @param removalStored |
| * @return |
| * @throws JavaModelException |
| */ |
| private boolean deleteTypes(CompilationUnit ast, Map<IType, List<DeleteEdit>> typeDeletes, |
| Map<IType, Integer> removalStored) throws JavaModelException { |
| if (!deleteEmpty) { |
| return false; |
| } |
| int typesDeleted = 0; |
| for (Map.Entry<IType, Integer> entry : removalStored.entrySet()) { |
| IType type = entry.getKey(); |
| int removals = entry.getValue(); |
| |
| // check to see if all of the type's children |
| // have been removed. If so, delete the type |
| if (type.getChildren().length == removals) { |
| @SuppressWarnings("unchecked") |
| List<AbstractTypeDeclaration> typeNodes = ast.types(); |
| for (AbstractTypeDeclaration typeNode : typeNodes) { |
| if (typeNode.getName().toString().equals(type.getElementName())) { |
| List<DeleteEdit> deletes = typeDeletes.get(type); |
| deletes.clear(); |
| deletes.add(new DeleteEdit(type.getSourceRange().getOffset(), type.getSourceRange().getLength())); |
| typesDeleted++; |
| } |
| } |
| } |
| } |
| |
| // check to see if all types have been deleted. |
| return (ast.types().size() == typesDeleted); |
| } |
| |
| |
| |
| private void applyTargetTypeEdits(IMember itd, |
| ICompilationUnit source, Collection<IMember> targets) throws CoreException, JavaModelException { |
| MultiTextEdit multiEdit = new MultiTextEdit(); |
| for (IMember target : targets) { |
| TextEdit edit = null; |
| if (itd instanceof IAspectJElement) { |
| IAspectJElement ajElement = (IAspectJElement) itd; |
| if (itd instanceof IntertypeElement) { |
| if (target instanceof IType) { |
| IType type = (IType) target; |
| // ignore ITD fields and constructors on interfaces |
| if (type.isInterface() && ajElement.getAJKind() != Kind.INTER_TYPE_METHOD) { |
| edit = null; |
| } else { |
| edit = createEditForITDTarget((IntertypeElement) itd, type); |
| } |
| } |
| } else if (ajElement.getAJKind().isDeclareAnnotation()) { |
| edit = createEditForDeclareTarget((DeclareElement) itd, target); |
| } |
| } else if (itd instanceof IType) { |
| // an ITIT |
| edit = createEditForIntertypeInnerType((IType) itd, (IType) target); |
| } |
| if (edit != null) { |
| multiEdit.addChild(edit); |
| } |
| } |
| |
| if (!isEmptyEdit(multiEdit)) { |
| TextFileChange change= (TextFileChange) allChanges.get(source); |
| if (change == null) { |
| change= new TextFileChange(source.getElementName(), (IFile) source.getResource()); |
| change.setTextType("java"); |
| change.setEdit(new MultiTextEdit()); |
| allChanges.put(source, change); |
| } |
| change.getEdit().addChild(multiEdit); |
| } |
| } |
| |
| |
| private String getQualifiedTypeForDeclareAnnotation(DeclareElement itd) { |
| IProgramElement ipe = getModel(itd).javaElementToProgramElement(itd); |
| if (ipe != null) { |
| return ipe.getAnnotationType(); |
| } |
| return null; |
| } |
| |
| /** |
| * Creates the text edit for pushing in an intertype inner type |
| * @param itit the intertype inner type to push in |
| * @param target the target to push the itit into. |
| * @return |
| */ |
| private TextEdit createEditForIntertypeInnerType(IType itit, IType target) throws JavaModelException { |
| String source = itit.getSource(); |
| // now, we must replace the '.' and the preceding identifier in the type name |
| int nameOffset = itit.getNameRange().getOffset() - itit.getSourceRange().getOffset(); |
| int dotOffset = source.lastIndexOf('$', nameOffset); |
| int classIndex = source.lastIndexOf("class ", dotOffset); |
| source = "\n\t" + source.substring(0, classIndex + "class ".length()) + source.substring(dotOffset + 1, source.length()) + "\n"; |
| return new InsertEdit(getITDInsertLocation(target), source); |
| } |
| |
| private TextEdit createEditForDeclareTarget(DeclareElement itd, |
| IMember target) throws JavaModelException { |
| DeclareElementInfo declareElementInfo = (DeclareElementInfo) itd.getElementInfo(); |
| if (declareElementInfo.isAnnotationRemover()) { |
| // must use the model to access removals |
| AJProjectModelFacade model = getModel(itd); |
| IProgramElement ipe = model.javaElementToProgramElement(itd); |
| return getAnnotationRemovalEdit(target, ipe.getRemovedAnnotationTypes()); |
| } else { |
| return new InsertEdit(getDeclareInsertLocation(target), getTextForDeclare(itd)); |
| } |
| } |
| |
| /** |
| * Delete the specified annotations on the target |
| * @param target target element to have annotations to delete |
| * @param removedAnnotationTypes annotations to delete |
| * @return the delete edit. May be a MultiText edit |
| * if multiple annotations are removed |
| * @throws JavaModelException |
| */ |
| private TextEdit getAnnotationRemovalEdit(IMember target, |
| String[] removedAnnotationTypes) throws JavaModelException { |
| if (target instanceof IAnnotatable) { |
| IAnnotatable annotatable = (IAnnotatable) target; |
| IAnnotation[] anns = annotatable.getAnnotations(); |
| List<DeleteEdit> deletes = new ArrayList<DeleteEdit>(removedAnnotationTypes.length); |
| for (String removedType : removedAnnotationTypes) { |
| // there can be only one match per removed type |
| // however, there can be two annotations with the |
| // same simple name on the member, but at least one has |
| // a matching qual name. |
| // So, if there is a simple name match, keep on looking, |
| // but a qual name match, end it. |
| DeleteEdit edit = null; |
| for (IAnnotation ann : anns) { |
| // don't know if ann is a simple or a qualified name, |
| // so check both. |
| String annName = ann.getElementName(); |
| boolean qualMatch = removedType.equals(annName); |
| boolean simpleMatch = removedType.endsWith("." + annName); |
| if (simpleMatch || qualMatch) { |
| // match! |
| ISourceRange range = ann.getSourceRange(); |
| edit = new DeleteEdit(range.getOffset(), range.getLength()); |
| if (qualMatch) { |
| // can only be one qualified match |
| break; |
| } |
| } |
| } |
| if (edit != null) { |
| deletes.add(edit); |
| } |
| } |
| if (deletes.size() == 0) { |
| return null; |
| } else if (deletes.size() == 1) { |
| return deletes.get(0); |
| } else { |
| MultiTextEdit multi = new MultiTextEdit(); |
| for (DeleteEdit delete : deletes) { |
| multi.addChild(delete); |
| } |
| return multi; |
| } |
| } else { |
| // nothing found |
| return null; |
| } |
| } |
| |
| private String getTextForDeclare(DeclareElement itd) throws JavaModelException { |
| IProgramElement ipe = getModel(itd).javaElementToProgramElement(itd); |
| if (ipe != null) { |
| String details = ipe.getDetails(); |
| int colonIndex = details.indexOf(':'); |
| String text = details.substring(colonIndex+1).trim(); |
| if (itd.getAJKind() == Kind.DECLARE_ANNOTATION_AT_TYPE) { |
| // assume top level type |
| return text + "\n"; |
| } else { |
| return text + "\n\t"; |
| } |
| } else { |
| throw new RuntimeException("Could not find program element in AspectJ model for " + itd.getHandleIdentifier()); |
| } |
| } |
| |
| private int getDeclareInsertLocation(IMember target) throws JavaModelException { |
| return target.getSourceRange().getOffset(); |
| } |
| |
| private TextEdit createEditForITDTarget(IntertypeElement itd, IType target) |
| throws JavaModelException { |
| // don't add fields or constructors to interfaces |
| TextEdit edit; |
| if (target.isInterface()) { |
| edit = new InsertEdit(getITDInsertLocation(target), getTargetTextForInterface(itd)); |
| } else { |
| edit = new InsertEdit(getITDInsertLocation(target), getTargetTextForClass(itd)); |
| } |
| return edit; |
| } |
| |
| private String getTargetTextForClass(IntertypeElement itd) throws JavaModelException { |
| String itdName = itd.getElementName(); |
| String[] splits = itdName.split("\\."); |
| String newName = splits[splits.length-1]; |
| itdName = itdName.replaceAll("\\.", "\\\\\\$"); |
| |
| // check for constructor |
| if (itdName.endsWith("_new")) { |
| // check to see if constructor |
| String maybeConstructor = itdName.substring(0, itdName.length()-"_new".length()); |
| String[] maybeConstructorArr = maybeConstructor.split("\\\\\\$"); |
| if (maybeConstructorArr.length == 2 && maybeConstructorArr[0].equals(maybeConstructorArr[1])) { |
| itdName = maybeConstructorArr[0] +"\\$new"; |
| newName = maybeConstructorArr[0]; |
| } |
| } |
| |
| String targetSource = getTargetSource(newName, itd); |
| targetSource = "\n\t" + targetSource + "\n"; |
| // also replace other pplaces where the itdName may exist |
| targetSource = targetSource.replaceAll(itdName, newName); |
| |
| return targetSource; |
| } |
| |
| private String getTargetTextForInterface(IntertypeElement itd) throws JavaModelException { |
| String itdName = itd.getElementName(); |
| String[] splits = itdName.split("\\."); |
| String newName = splits[splits.length-1]; |
| itdName = itdName.replaceAll("\\.", "\\\\\\$"); |
| String targetSource = getTargetSource(newName, itd); |
| int closeParen = targetSource.indexOf(")"); // assumption here...closing paren doesn't exist in comments |
| if (closeParen >= 0) { |
| targetSource = targetSource.substring(0, closeParen+1) + ';'; |
| } |
| targetSource = "\n\t" + targetSource + "\n\n"; |
| // also replace any other occurrences of the itdName |
| targetSource = targetSource.replaceAll(itdName, newName); |
| return targetSource; |
| } |
| |
| /** |
| * get the target source and replace the ITD name with the new name |
| * @param newName |
| * @param itd |
| * @return |
| * @throws JavaModelException |
| */ |
| private String getTargetSource(String newName, IntertypeElement itd) throws JavaModelException { |
| int itdStart = itd.getSourceRange().getOffset(); |
| int itdNameStart = itd.getTargetTypeSourceRange().getOffset() - itdStart; |
| int itdNameEnd = itd.getNameRange().getOffset() + itd.getNameRange().getLength() - itdStart; |
| String targetSource = itd.getSource(); |
| targetSource = targetSource.substring(0, itdNameStart) + newName + targetSource.substring(itdNameEnd); |
| return targetSource; |
| } |
| |
| private int getITDInsertLocation(IType type) throws JavaModelException { |
| return type.getSourceRange().getOffset()+type.getSourceRange().getLength()-1; |
| } |
| |
| |
| private void applyAspectEdits(ICompilationUnit source, Map<IType, List<DeleteEdit>> typeDeletes) throws JavaModelException, |
| CoreException { |
| MultiTextEdit edit = new MultiTextEdit(); |
| for (List<DeleteEdit> deletesForOneType : typeDeletes.values()) { |
| for (DeleteEdit delete : deletesForOneType) { |
| edit.addChild(delete); |
| } |
| } |
| |
| if (!isEmptyEdit(edit)) { |
| TextFileChange change= (TextFileChange) allChanges.get(source); |
| if (change == null) { |
| change= new TextFileChange(source.getElementName(), (IFile) source.getResource()); |
| change.setTextType("java"); |
| change.setEdit(edit); |
| allChanges.put(source, change); |
| } else { |
| change.getEdit().addChild(edit); |
| } |
| } |
| } |
| |
| |
| |
| |
| /** |
| * Finds all of the compilation units for the given array of target elements |
| * @param targets an array of target elements that are the target of ITDs in a single Aspect |
| * @return all of the targets grouped by their {@link ICompilationUnit} |
| */ |
| private Map<ICompilationUnit, Set<IMember>> getUnitTypeMap(IMember[] targets) { |
| Map<ICompilationUnit, Set<IMember>> unitToTypes = new HashMap<ICompilationUnit, Set<IMember>>(); |
| for (int i = 0; i < targets.length; i++) { |
| IMember target = targets[i]; |
| ICompilationUnit unit = target.getCompilationUnit(); |
| Set<IMember> currTypes; |
| if (unitToTypes.containsKey(unit)) { |
| currTypes = unitToTypes.get(unit); |
| } else { |
| currTypes = new HashSet<IMember>(); |
| unitToTypes.put(unit, currTypes); |
| } |
| currTypes.add(target); |
| } |
| return unitToTypes; |
| } |
| |
| @Override |
| public RefactoringStatus checkInitialConditions(IProgressMonitor monitor) |
| throws CoreException, OperationCanceledException { |
| if (monitor == null) { |
| monitor = new NullProgressMonitor(); |
| } |
| RefactoringStatus status= new RefactoringStatus(); |
| |
| monitor.beginTask("Checking preconditions...", 1); |
| |
| if (itds.isEmpty()) { |
| return RefactoringStatus.createWarningStatus("No Intertype declarations selected. Nothing to do."); |
| } |
| |
| try { |
| for (IMember itd : itds) { |
| status.merge(initialITDCheck(itd)); |
| } |
| } finally { |
| monitor.done(); |
| } |
| return status; |
| } |
| |
| |
| private RefactoringStatus initialITDCheck(IMember itd) { |
| RefactoringStatus status= new RefactoringStatus(); |
| |
| if (itd == null) { |
| status.merge(RefactoringStatus.createFatalErrorStatus("Intertype declaration has not been specified")); |
| return status; |
| } |
| if (! (itd instanceof IAspectJElement)) { |
| return status; |
| } |
| try { |
| AJProjectModelFacade model = getModel(itd); |
| if (!model.hasModel()) { |
| status.merge(RefactoringStatus.createFatalErrorStatus("No crosscutting model available. Rebuild project.")); |
| } |
| ICompilationUnit unit = itd.getCompilationUnit(); |
| Object[] itdName = new Object[] { unit.getElementName()}; |
| if (!itd.exists()) { |
| status.merge(RefactoringStatus.createFatalErrorStatus(MessageFormat.format("ITD ''{0}'' does not exist.", new Object[] { itd.getElementName()}))); |
| } else if (!unit.isStructureKnown()) { |
| status.merge(RefactoringStatus.createFatalErrorStatus(MessageFormat.format("Compilation unit ''{0}'' contains compile errors.", itdName))); |
| } else |
| try { |
| if (unit.getResource().findMaxProblemSeverity(IMarker.MARKER, true, IResource.DEPTH_ZERO) >= IMarker.SEVERITY_ERROR) { |
| status.merge(RefactoringStatus.createFatalErrorStatus(MessageFormat.format("Compilation unit ''{0}'' contains compile errors.", itdName))); |
| } |
| } catch (CoreException e) { |
| status.merge(RefactoringStatus.create(e.getStatus())); |
| } |
| // now check target types |
| IMember[] targets = getTargets(Collections.singletonList(itd)); |
| if (targets.length > 0) { |
| for (int i = 0; i < targets.length; i++) { |
| IMember target = targets[i]; |
| if (!target.exists()) { |
| status.merge(RefactoringStatus.createFatalErrorStatus( |
| MessageFormat.format("Target type ''{0}'' does not exist.", new Object[] { target.getElementName()}))); |
| } else if (target.isBinary()) { |
| status.merge(RefactoringStatus.createFatalErrorStatus( |
| MessageFormat.format("Target type ''{0}'' is binary.", new Object[] { target.getElementName()}))); |
| } else if (!unit.isStructureKnown()) { |
| status.merge(RefactoringStatus.createFatalErrorStatus( |
| MessageFormat.format("Compilation unit ''{0}'' contains compile errors.", |
| new Object[] { target.getCompilationUnit().getElementName()}))); |
| } |
| } |
| } else { |
| status.merge(RefactoringStatus.createWarningStatus(MessageFormat.format("ITD ''{0}'' has no target. This refactoring will delete the declaration. " + |
| "Perhaps there is an unresolved compilation error?", itd.getElementName()))); |
| } |
| } catch (JavaModelException e) { |
| status.addFatalError("JavaModelException:\n\t" + e.getMessage() + "\n\t" + e.getJavaModelStatus().getMessage()); |
| } |
| return status; |
| } |
| |
| |
| @Override |
| public Change createChange(IProgressMonitor monitor) throws CoreException, |
| OperationCanceledException { |
| monitor.beginTask("Creating change...", 1); |
| try { |
| final Collection<Change> changes= allChanges.values(); |
| CompositeChange change= new CompositeChange(getName(), changes.toArray(new Change[changes.size()])) { |
| |
| @Override |
| public ChangeDescriptor getDescriptor() { |
| return new RefactoringChangeDescriptor(createDescriptor()); |
| } |
| |
| }; |
| return change; |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| public PushInRefactoringDescriptor createDescriptor() { |
| StringBuffer projectsb = new StringBuffer(); |
| StringBuffer descriptionsb = new StringBuffer(); |
| StringBuffer commentsb = new StringBuffer(); |
| StringBuffer argssb = new StringBuffer(); |
| for (IMember itd : itds) { |
| projectsb.append(itd.getJavaProject().getElementName() + "\n"); |
| descriptionsb.append(MessageFormat.format("Push In intertype declaration for ''{0}''\n", new Object[] { itd.getElementName()})); |
| String itdLabel = getModel(itd).getJavaElementLinkName(itd); |
| commentsb.append(MessageFormat.format("Push In intertype declaration for ''{0}''\n", new Object[] { itdLabel })); |
| argssb.append(itd.getHandleIdentifier() + "\n"); |
| } |
| Map<String, String> arguments = new HashMap<String, String>(); |
| arguments.put(ALL_ITDS, argssb.toString()); |
| return new PushInRefactoringDescriptor( |
| projectsb.toString(), |
| descriptionsb.toString(), |
| commentsb.toString(), |
| arguments); |
| } |
| |
| |
| @Override |
| public String getName() { |
| return "Push-In"; |
| } |
| |
| |
| public RefactoringStatus initialize(Map<String, String> arguments) { |
| String value= arguments.get(ALL_ITDS); |
| if (value != null) { |
| String[] values = value.split("\\n"); |
| List<IMember> newitds = new ArrayList<IMember>(values.length); |
| for (int i = 0; i < values.length; i++) { |
| newitds.add((IMember) AspectJCore.create(value)); |
| } |
| setITDs(newitds); |
| return new RefactoringStatus(); |
| } else { |
| return RefactoringStatus.createErrorStatus("No ITD specified."); |
| } |
| } |
| |
| public void setITDs(List<IMember> itds) { |
| this.itds = itds; |
| } |
| |
| public List<IMember> getITDs() { |
| return itds; |
| } |
| |
| |
| /** |
| * This method determines all of the targets of the set of ITDs passed in. |
| * it does not distinguish between which type is affected by which ITD |
| * later, we need to do that filtering |
| * @param itds set of ITDs to putsh in from a single compilation unit |
| * @return array of target elements for these ITDs. |
| * @throws JavaModelException |
| */ |
| private IMember[] getTargets(List<IMember> itds) throws JavaModelException { |
| AJProjectModelFacade model = getModel(itds.get(0)); |
| List<IMember> targets = new ArrayList<IMember>(); |
| |
| for (IMember itd : itds) { |
| List<IJavaElement> elts; |
| AJRelationshipType relationship = itd instanceof IAspectJElement && ((IAspectJElement) itd).getAJKind().isDeclareAnnotation() ? |
| AJRelationshipManager.ANNOTATES : |
| // either an ITD or an ITIT (IType) |
| AJRelationshipManager.DECLARED_ON; |
| elts = model.getRelationshipsForElement(itd, relationship); |
| |
| for (IJavaElement elt : elts) { |
| targets.add((IMember) elt); |
| } |
| } |
| return targets.toArray(new IMember[targets.size()]); |
| } |
| |
| private boolean isEmptyEdit(TextEdit edit) { |
| return edit.getClass() == MultiTextEdit.class && !edit.hasChildren(); |
| } |
| |
| private boolean isCUnitContainingITD(ICompilationUnit unit, IMember itd) { |
| return itd != null && itd.getCompilationUnit().equals(unit); |
| } |
| } |
