spoon.reflect.visitor

Class ImportCleaner

java.lang.Object

spoon.processing.AbstractProcessor<CtElement>

spoon.reflect.visitor.ImportCleaner

All Implemented Interfaces:

FactoryAccessor, Processor<CtElement>

public class ImportCleaner
extends AbstractProcessor<CtElement>

Updates list of import statements of compilation unit following CtElement.isImplicit(). Can be configured to add or remove imports using setCanAddImports(boolean) and setCanRemoveImports(boolean). This does not force some references to be implicit, and doesn't fix the wrong implicit which causes conflicts: this fixing done by ImportConflictDetector

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	ImportCleaner.Context a set of imports for a given compilation unit
class	ImportCleaner.ImportCleanerScanner A scanner that initializes context for a compilation unit.

Field Summary

Fields

Modifier and Type	Field and Description
protected static Set<CtRole>	IGNORED_ROLES_WHEN_IMPLICIT
protected EarlyTerminatingScanner	scanner

Constructor Summary

Constructors

Constructor and Description
ImportCleaner()

Method Summary

Modifier and Type	Method and Description
protected ImportCleaner.ImportCleanerScanner	createScanner() creates the scanner that will be used to visit the model
protected CtScannerListener	createScannerListener()
Comparator<CtImport>	getImportComparator()
protected static <T extends CtElement> T	getParentIfType(CtElement element, Class<T> type)
protected ImportCleaner.Context	getScannerContextInformation() extract the required information from the scanner to take a decision
protected void	handleTargetedExpression(CtTargetedExpression<?,?> targetedExpression, ImportCleaner.Context context) what do we do a target expression (print target or not) ?
protected void	handleTypeReference(CtTypeReference<?> reference, ImportCleaner.Context context, CtRole role) what do we do a type reference?
boolean	isCanAddImports()
boolean	isCanRemoveImports()
protected void	onEnter(U context, CtRole role, CtElement element)
void	process(CtElement el) A callback method upcalled by the meta-model scanner to perform a dedicated job on the currently scanned element.
protected static void	process(CtScanner scanner, CtCompilationUnit cu)
ImportCleaner	setCanAddImports(boolean canAddImports)
ImportCleaner	setCanRemoveImports(boolean canRemoveImports)
ImportCleaner	setImportComparator(Comparator<CtImport> importComparator)

Methods inherited from class spoon.processing.AbstractProcessor

addProcessedElementType, clearProcessedElementType, getEnvironment, getFactory, getProcessedElementTypes, getTraversalStrategy, init, initProperties, interrupt, isToBeProcessed, loadProperties, process, processingDone, removeProcessedElementType, setFactory

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

scanner

protected EarlyTerminatingScanner scanner

IGNORED_ROLES_WHEN_IMPLICIT

protected static Set<CtRole> IGNORED_ROLES_WHEN_IMPLICIT

Constructor Detail

ImportCleaner

public ImportCleaner()

Method Detail

createScanner

protected ImportCleaner.ImportCleanerScanner createScanner()

creates the scanner that will be used to visit the model

getScannerContextInformation

protected ImportCleaner.Context getScannerContextInformation()

extract the required information from the scanner to take a decision

handleTargetedExpression

protected void handleTargetedExpression(CtTargetedExpression<?,?> targetedExpression,
                                        ImportCleaner.Context context)

what do we do a target expression (print target or not) ?

handleTypeReference

protected void handleTypeReference(CtTypeReference<?> reference,
                                   ImportCleaner.Context context,
                                   CtRole role)

what do we do a type reference?

isCanAddImports

public boolean isCanAddImports()

Returns:

true if this processor is allowed to add new imports

setCanAddImports

public ImportCleaner setCanAddImports(boolean canAddImports)

Parameters:

canAddImports - true if this processor is allowed to add new imports

isCanRemoveImports

public boolean isCanRemoveImports()

Returns:

true if this processor is allowed to remove imports

setCanRemoveImports

public ImportCleaner setCanRemoveImports(boolean canRemoveImports)

Parameters:

canRemoveImports - true if this processor is allowed to remove imports

getImportComparator

public Comparator<CtImport> getImportComparator()

setImportComparator

public ImportCleaner setImportComparator(Comparator<CtImport> importComparator)

process

public void process(CtElement el)

Description copied from interface: Processor

A callback method upcalled by the meta-model scanner to perform a dedicated job on the currently scanned element. The way Spoon upcalls this method depends on the processed element types ( Processor.getProcessedElementTypes()), the traversal strategy ( Processor.getTraversalStrategy()), and the used processing manager ( Environment.getManager(). Also, this method is upcalled only if the method Processor.isToBeProcessed(CtElement) returns true for a given scanned element. In order to manually scan the meta-model, one can define the Processor.process() method instead.

Parameters:

el - the element that is currently being scanned

process

protected static void process(CtScanner scanner,
                              CtCompilationUnit cu)

createScannerListener

protected CtScannerListener createScannerListener()

onEnter

protected void onEnter(U context,
                       CtRole role,
                       CtElement element)

getParentIfType

protected static <T extends CtElement> T getParentIfType(CtElement element,
                                                         Class<T> type)

Returns:

parent of `element`, but only if it's type is `type`