public ImportRemover getImportRemover() { if (fImportRemover == null) { fImportRemover= new ImportRemover(fCu.getJavaProject(), getRoot()); } return fImportRemover; } }
@Override protected ASTRewrite getRewrite() throws CoreException { ASTRewrite rewrite= super.getRewrite(); ImportRewrite importRewrite= getImportRewrite(); if (fImportRemover != null && importRewrite != null) { fImportRemover.applyRemoves(importRewrite); } return rewrite; }
private void rewriteExpression(ASTNode node, Expression exp, ITypeBinding type) { fCuRewrite.getASTRewrite().replace(exp, fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST()), fCuRewrite.createGroupDescription(REFERENCE_UPDATE)); fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName()); fCuRewrite.getImportRemover().registerRemovedNode(exp); fNeedsImport= true; nonStaticAccess(node); }
public IBinding[] getImportsToRemove() { ArrayList<SimpleName> importNames= new ArrayList<>(); ArrayList<SimpleName> staticNames= new ArrayList<>(); ImportReferencesCollector.collect(fRoot, fProject, null, importNames, staticNames); List<SimpleName> removedRefs= new ArrayList<>(); List<SimpleName> unremovedRefs= new ArrayList<>(); divideTypeRefs(importNames, staticNames, removedRefs, unremovedRefs); if (removedRefs.size() == 0) return new IBinding[0]; HashMap<String, IBinding> potentialRemoves= getPotentialRemoves(removedRefs); for (Iterator<SimpleName> iterator= unremovedRefs.iterator(); iterator.hasNext();) { SimpleName name= iterator.next(); potentialRemoves.remove(name.getIdentifier()); } Collection<IBinding> importsToRemove= potentialRemoves.values(); return importsToRemove.toArray(new IBinding[importsToRemove.size()]); }
if (excludeBindings == null || !excludeBindings.contains(type)) { typeImports.put(name, rewriter.addImport(type, context)); remover.registerAddedImport(((SimpleName)name).getIdentifier()); if (declaring != null && (excludeBindings == null || !excludeBindings.contains(variable))) { staticImports.put(name, rewriter.addStaticImport(variable, context)); remover.registerAddedStaticImport(declaring.getQualifiedName(), variable.getName(), true); if (declaring != null && (excludeBindings == null || !excludeBindings.contains(method))) { staticImports.put(name, rewriter.addStaticImport(method, context)); remover.registerAddedStaticImport(declaring.getQualifiedName(), method.getName(), false);
if (createExplicitlyTypedParameters) { lambdaParameters.add((SingleVariableDeclaration) rewrite.createCopyTarget(methodParameter)); importRemover.registerRetainedNode(methodParameter); } else { VariableDeclarationFragment lambdaParameter = ast.newVariableDeclarationFragment(); Type castType = importRewrite.addImport(classInstanceCreation.getType().resolveBinding(), ast, importRewriteContext, TypeLocation.CAST); cast.setType(castType); importRemover.registerAddedImports(castType); replacement = cast; importRemover.registerRemovedNode(classInstanceCreation); importRemover.registerRetainedNode(lambdaBody);
public Type importBinding(ITypeBinding newTypeBinding, CompilationUnitRewrite cuRewrite, ImportRewriteContext context) { Type type= cuRewrite.getImportRewrite().addImport(newTypeBinding, cuRewrite.getAST(), context); cuRewrite.getImportRemover().registerAddedImports(type); return type; }
private void addExceptionToNodeList(ExceptionInfo exceptionInfo, ListRewrite exceptionListRewrite) { String fullyQualified= exceptionInfo.getFullyQualifiedName(); for (Iterator<? extends ASTNode> iter= exceptionListRewrite.getOriginalList().iterator(); iter.hasNext(); ) { Type exType= (Type) iter.next(); //XXX: existing superclasses of the added exception are redundant and could be removed ITypeBinding typeBinding= exType.resolveBinding(); if (typeBinding == null) continue; // newly added or unresolvable type if (typeBinding.getQualifiedName().equals(fullyQualified)) return; // don't add it again } String importedType= getImportRewrite().addImport(exceptionInfo.getFullyQualifiedName()); getImportRemover().registerAddedImport(importedType); ASTNode exNode= getASTRewrite().createStringPlaceholder(importedType, ASTNode.SIMPLE_TYPE); exceptionListRewrite.insertLast(exNode, fDescription); }
private void removeNode(ASTNode parent, TextEditGroup removeFieldGroup, CompilationUnitRewrite baseCURewrite) { baseCURewrite.getASTRewrite().remove(parent, removeFieldGroup); baseCURewrite.getImportRemover().registerRemovedNode(parent); }
if (parent != null && list.getRewrittenList().contains(parent)) { list.remove(parent, null); remover.registerRemovedNode(parent); final ITypeBinding elementType= getElementType(fIteratorVariable.getType()); Type importType= importType(elementType, getForStatement(), importRewrite, getRoot()); remover.registerAddedImports(importType); declaration.setType(importType); if (fMakeFinal) { ModifierRewrite.create(astRewrite, declaration).setModifiers(Modifier.FINAL, 0, group); remover.registerAddedImport(elementType.getQualifiedName()); fEnhancedForLoop.setParameter(declaration); fEnhancedForLoop.setExpression(getExpression(astRewrite)); if (node instanceof VariableDeclarationExpression) { VariableDeclarationExpression variableDeclarationExpression= (VariableDeclarationExpression) node; remover.registerRemovedNode(variableDeclarationExpression.getType()); } else { remover.registerRemovedNode(node); remover.registerRemovedNode(node);
ASTRewrite rewrite= ASTRewrite.create(ast); ImportRemover remover= new ImportRemover(context.getCompilationUnit().getJavaProject(), context.getASTRoot()); oldType= curParent.getType(); if (oldType != null && (!checkForVarTypes || (checkForVarTypes && !oldType.isVar()))) { remover.registerRemovedNode(oldType); removeImports= true;
ImportRemover remover= new ImportRemover(getCompilationUnit().getJavaProject(), newRoot); Type type; if (fIsNewTypeVar) { TypeAnnotationRewrite.removePureTypeAnnotations(parent, VariableDeclarationStatement.MODIFIERS2_PROPERTY, rewrite, null); if (oldType != null) { remover.registerRemovedNode(oldType); TypeAnnotationRewrite.removePureTypeAnnotations(parent, VariableDeclarationExpression.MODIFIERS2_PROPERTY, rewrite, null); if (oldType != null) { remover.registerRemovedNode(oldType); if (fIsNewTypeVar) { if (oldType != null) { remover.registerRemovedNode(oldType); remover.applyRemoves(imports);
try { boolean needsAstRewrite= fRewrite != null; // TODO: do we need something like ASTRewrite#hasChanges() here? boolean needsImportRemoval= fImportRemover != null && fImportRemover.hasRemovedNodes(); boolean needsImportRewrite= fImportRewrite != null && fImportRewrite.hasRecordedChanges() || needsImportRemoval; if (!needsAstRewrite && !needsImportRemoval && !needsImportRewrite) fImportRemover.applyRemoves(getImportRewrite());
private HashMap<String, IBinding> getPotentialRemoves(List<SimpleName> removedRefs) { HashMap<String, IBinding>potentialRemoves= new HashMap<>(); for (Iterator<SimpleName> iterator= removedRefs.iterator(); iterator.hasNext();) { SimpleName name= iterator.next(); if (fAddedImports.contains(name.getIdentifier()) || hasAddedStaticImport(name)) continue; IBinding binding= name.resolveBinding(); if (binding != null) potentialRemoves.put(name.getIdentifier(), binding); } return potentialRemoves; }
private void importStatically(SimpleName toImport, IBinding binding) { String newName= fNewLocationCuRewrite.getImportRewrite().addStaticImport(binding); fNewLocationCuRewrite.getImportRemover().registerAddedStaticImport(binding); Name newReference= ASTNodeFactory.newName(fInitializerRewrite.getAST(), newName); fInitializerRewrite.replace(toImport, newReference, null); }
public void applyRemoves(ImportRewrite importRewrite) { IBinding[] bindings= getImportsToRemove(); for (int i= 0; i < bindings.length; i++) { if (bindings[i] instanceof ITypeBinding) { ITypeBinding typeBinding= (ITypeBinding) bindings[i]; importRewrite.removeImport(typeBinding.getTypeDeclaration().getQualifiedName()); } else if (bindings[i] instanceof IMethodBinding) { IMethodBinding binding= (IMethodBinding) bindings[i]; importRewrite.removeStaticImport(binding.getDeclaringClass().getQualifiedName() + '.' + binding.getName()); } else if (bindings[i] instanceof IVariableBinding) { IVariableBinding binding= (IVariableBinding) bindings[i]; importRewrite.removeStaticImport(binding.getDeclaringClass().getQualifiedName() + '.' + binding.getName()); } } } }
if (createExplicitlyTypedParameters) { lambdaParameters.add((SingleVariableDeclaration) rewrite.createCopyTarget(methodParameter)); importRemover.registerRetainedNode(methodParameter); } else { VariableDeclarationFragment lambdaParameter= ast.newVariableDeclarationFragment(); Type castType= importRewrite.addImport(classInstanceCreation.getType().resolveBinding(), ast, importRewriteContext); cast.setType(castType); importRemover.registerAddedImports(castType); replacement= cast; importRemover.registerRemovedNode(classInstanceCreation); importRemover.registerRetainedNode(lambdaBody);
private Type importBinding(ITypeBinding typeBinding, CompilationUnitRewrite cuRewrite) { Type type= cuRewrite.getImportRewrite().addImport(typeBinding, cuRewrite.getAST()); cuRewrite.getImportRemover().registerAddedImports(type); return type; }
public Type createType(boolean asTopLevelClass, CompilationUnitRewrite cuRewrite, int position) { String qualifier= asTopLevelClass ? fPackage : fEnclosingType; String concatenateName= JavaModelUtil.concatenateName(qualifier, fClassName); ImportRewrite importRewrite= cuRewrite.getImportRewrite(); ContextSensitiveImportRewriteContext context= createParameterClassAwareContext(asTopLevelClass, cuRewrite, position); String addedImport= importRewrite.addImport(concatenateName, context); cuRewrite.getImportRemover().registerAddedImport(addedImport); AST ast= cuRewrite.getAST(); return ast.newSimpleType(ast.newName(addedImport)); }
private static void markAsDeleted(List<ASTNode> list, IJavaElement element, CompilationUnitRewrite rewrite, TextEditGroup group) throws JavaModelException { ASTNode[] declarationNodes= getNodesToDelete(element, rewrite.getRoot()); for (int i= 0; i < declarationNodes.length; i++) { ASTNode node= declarationNodes[i]; if (node != null) { list.add(node); rewrite.getASTRewrite().remove(node, group); rewrite.getImportRemover().registerRemovedNode(node); } } }