java.lang.Object
- spoon.reflect.visitor.CtInheritanceScanner

All Implemented Interfaces:

CtVisitor

Direct Known Subclasses:

CloneBuilder, EqualsChecker, HashcodeVisitor, ParentExiter
```
public abstract class CtInheritanceScanner
extends Object
implements CtVisitor
```
This class provides an abstract implementation of the visitor that allows its subclasses to scan the metamodel elements by recursively using their (abstract) supertype scanning methods. It declares a scan method for each abstract element of the AST and a visit method for each element of the AST.

Constructor Summary

Constructors
Constructor Description

CtInheritanceScanner()
Default constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`scan(Collection<? extends CtElement> elements)`	Generically scans a collection of meta-model elements.
`void`	`scan(CtElement element)`	Generically scans a meta-model element.
`<T> void`	`scanCtAbstractInvocation(CtAbstractInvocation<T> a)`	Scans an abstract invocation.
`<S> void`	`scanCtAbstractSwitch(CtAbstractSwitch<S> a)`	Scans an abstract switch (either switch statement or switch expression).
`void`	`scanCtActualTypeContainer(CtActualTypeContainer reference)`	Scans an actual type container..
`<T,E extends CtExpression<?>> void`	`scanCtArrayAccess(CtArrayAccess<T,E> arrayAccess)`	Scans an array access (read and write).
`void`	`scanCtBodyHolder(CtBodyHolder ctBodyHolder)`	Scans a body holder
`void`	`scanCtCFlowBreak(CtCFlowBreak flowBreak)`	Scans an abstract control flow break.
`void`	`scanCtCodeElement(CtCodeElement e)`	Scans an abstract code element.
`void`	`scanCtCodeSnippet(CtCodeSnippet snippet)`
`void`	`scanCtElement(CtElement e)`	Scans an abstract element.
`<R> void`	`scanCtExecutable(CtExecutable<R> e)`	Scans an abstract executable.
`<T> void`	`scanCtExpression(CtExpression<T> expression)`	Scans an abstract expression.
`<T> void`	`scanCtFieldAccess(CtFieldAccess<T> fieldAccess)`	Scans a field access (read and write).
`void`	`scanCtFormalTypeDeclarer(CtFormalTypeDeclarer e)`	Scans a formal type declarer.
`void`	`scanCtLabelledFlowBreak(CtLabelledFlowBreak labelledFlowBreak)`	Scans a labelled control flow break.
`void`	`scanCtLoop(CtLoop loop)`	Scans an abstract loop.
`void`	`scanCtModifiable(CtModifiable m)`	Scans an abstract modifiable element.
`void`	`scanCtModuleDirective(CtModuleDirective e)`
`void`	`scanCtMultiTypedElement(CtMultiTypedElement f)`
`void`	`scanCtNamedElement(CtNamedElement e)`	Scans an abstract named element.
`void`	`scanCtReference(CtReference reference)`	Scans an abstract reference.
`<T> void`	`scanCtRHSReceiver(CtRHSReceiver<T> ctRHSReceiver)`	Scans the right-hand side of an assignment
`void`	`scanCtShadowable(CtShadowable ctShadowable)`	Scans a shadowable element
`void`	`scanCtStatement(CtStatement s)`	Scans an abstract statement.
`<T,E extends CtExpression<?>> void`	`scanCtTargetedExpression(CtTargetedExpression<T,E> targetedExpression)`	Scans an abstract targeted expression.
`<T> void`	`scanCtType(CtType<T> type)`	Scans an abstract type.
`<T> void`	`scanCtTypedElement(CtTypedElement<T> e)`	Scans an abstract typed element.
`<T> void`	`scanCtTypeInformation(CtTypeInformation typeInfo)`	Scans an abstract variable reference.
`void`	`scanCtTypeMember(CtTypeMember e)`
`<T> void`	`scanCtVariable(CtVariable<T> v)`	Scans an abstract variable declaration.
`<T> void`	`scanCtVariableAccess(CtVariableAccess<T> variableAccess)`	Scans a variable access (read and write).
`<T> void`	`scanCtVariableReference(CtVariableReference<T> reference)`	Scans an abstract variable reference.
`void`	`scanCtVisitable(CtVisitable e)`
`<A extends Annotation> void`	`visitCtAnnotation(CtAnnotation<A> e)`	Visits an annotation.
`<T> void`	`visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> e)`	Visits a field of an annotation.
`<T> void`	`visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)`	Visits an annotation method declaration.
`<A extends Annotation> void`	`visitCtAnnotationType(CtAnnotationType<A> e)`	Visits an annotation type declaration.
`void`	`visitCtAnonymousExecutable(CtAnonymousExecutable e)`	Visits an anonymous executable.
`<T> void`	`visitCtArrayRead(CtArrayRead<T> arrayRead)`	Visits an array read access.
`<T> void`	`visitCtArrayTypeReference(CtArrayTypeReference<T> e)`	Visits a reference to an array type.
`<T> void`	`visitCtArrayWrite(CtArrayWrite<T> arrayWrite)`	Visits an array write access.
`<T> void`	`visitCtAssert(CtAssert<T> e)`	Visits an assert.
`<T,A extends T> void`	`visitCtAssignment(CtAssignment<T,A> e)`	Visits an assignment.
`<T> void`	`visitCtBinaryOperator(CtBinaryOperator<T> e)`	Visits a binary operator.
`<R> void`	`visitCtBlock(CtBlock<R> e)`	Visits a block of code.
`void`	`visitCtBreak(CtBreak e)`	Visits a `break` statement.
`<E> void`	`visitCtCase(CtCase<E> e)`	Visits a `case` clause.
`void`	`visitCtCatch(CtCatch e)`	Visits a `catch` clause.
`<T> void`	`visitCtCatchVariable(CtCatchVariable<T> e)`	Visits a catch variable declaration.
`<T> void`	`visitCtCatchVariableReference(CtCatchVariableReference<T> e)`	Visits a reference to a catch variable.
`<T> void`	`visitCtClass(CtClass<T> e)`	Visits a class declaration.
`<T> void`	`visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> e)`	Visits a code snippet expression.
`void`	`visitCtCodeSnippetStatement(CtCodeSnippetStatement e)`	Visits a code snippet statement.
`void`	`visitCtComment(CtComment e)`	Visits a comment
`void`	`visitCtCompilationUnit(CtCompilationUnit compilationUnit)`	Visits a compilation unit
`<T> void`	`visitCtConditional(CtConditional<T> e)`	Visits a conditional expression
`<T> void`	`visitCtConstructor(CtConstructor<T> e)`	Visits a constructor declaration.
`<T> void`	`visitCtConstructorCall(CtConstructorCall<T> e)`	Visits a call to a constructor.
`void`	`visitCtContinue(CtContinue e)`	Visits a `continue` statement.
`void`	`visitCtDo(CtDo e)`	Visits a `do` loop.
`<T extends Enum<?>> void`	`visitCtEnum(CtEnum<T> e)`	Visits an enumeration declaration.
`<T> void`	`visitCtEnumValue(CtEnumValue<T> enumValue)`	Visits an enum value declaration.
`<T> void`	`visitCtExecutableReference(CtExecutableReference<T> e)`	Visits a reference to an executable.
`<T,E extends CtExpression<?>> void`	`visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> e)`	Visits a reference to an executable.
`<T> void`	`visitCtField(CtField<T> e)`	Visits a field declaration.
`<T> void`	`visitCtFieldRead(CtFieldRead<T> fieldRead)`	Visits a field read access.
`<T> void`	`visitCtFieldReference(CtFieldReference<T> e)`	Visits a reference to a field.
`<T> void`	`visitCtFieldWrite(CtFieldWrite<T> fieldWrite)`	Visits a field write access.
`void`	`visitCtFor(CtFor e)`	Visits a `for` loop.
`void`	`visitCtForEach(CtForEach e)`	Visits an enhanced `for` loop.
`void`	`visitCtIf(CtIf e)`	Visits an `if` statement.
`void`	`visitCtImport(CtImport ctImport)`	Visits an import declaration
`<T> void`	`visitCtInterface(CtInterface<T> e)`	Visits an interface declaration.
`<T> void`	`visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> e)`	Visits an intersection type.
`<T> void`	`visitCtInvocation(CtInvocation<T> e)`	Visits an executable invocation.
`void`	`visitCtJavaDoc(CtJavaDoc e)`	Visits a javadoc comment
`void`	`visitCtJavaDocTag(CtJavaDocTag e)`	Visits a javadoc tag
`<T> void`	`visitCtLambda(CtLambda<T> e)`	Visits an anonymous method construction.
`<T> void`	`visitCtLiteral(CtLiteral<T> e)`	Visits a literal expression.
`<T> void`	`visitCtLocalVariable(CtLocalVariable<T> e)`	Visits a local variable declaration.
`<T> void`	`visitCtLocalVariableReference(CtLocalVariableReference<T> e)`	Visits a reference to a local variable.
`<T> void`	`visitCtMethod(CtMethod<T> e)`	Visits a method declaration.
`void`	`visitCtModule(CtModule module)`	Visits a module declaration
`void`	`visitCtModuleReference(CtModuleReference moduleReference)`	Visits a module reference
`void`	`visitCtModuleRequirement(CtModuleRequirement moduleRequirement)`	Visits a "require" directive in a module declaration.
`<T> void`	`visitCtNewArray(CtNewArray<T> e)`	Visits an array construction.
`<T> void`	`visitCtNewClass(CtNewClass<T> e)`	Visits an anonymous class construction.
`<T,A extends T> void`	`visitCtOperatorAssignement(CtOperatorAssignment<T,A> assignment)`
`<T,A extends T> void`	`visitCtOperatorAssignment(CtOperatorAssignment<T,A> e)`	Visits an operator assignment.
`void`	`visitCtPackage(CtPackage e)`	Visits a package declaration.
`void`	`visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)`	Visits a package declaration
`void`	`visitCtPackageExport(CtPackageExport moduleExport)`	Visits a package export in a module declaration.
`void`	`visitCtPackageReference(CtPackageReference e)`	Visits a reference to a package.
`<T> void`	`visitCtParameter(CtParameter<T> e)`	Visits a parameter declaration.
`<T> void`	`visitCtParameterReference(CtParameterReference<T> e)`	Visits a reference to a parameter.
`void`	`visitCtProvidedService(CtProvidedService moduleProvidedService)`	Visits a "provides" directive in a module declaration.
`<R> void`	`visitCtReturn(CtReturn<R> e)`	Visits a `return` statement.
`<R> void`	`visitCtStatementList(CtStatementList e)`	Visits a statement list.
`<T> void`	`visitCtSuperAccess(CtSuperAccess<T> f)`	Visits an access to a super invocation.
`<E> void`	`visitCtSwitch(CtSwitch<E> e)`	Visits a `switch` statement.
`<T,S> void`	`visitCtSwitchExpression(CtSwitchExpression<T,S> e)`	Visits a `switch` expression.
`void`	`visitCtSynchronized(CtSynchronized e)`	Visits a `synchronized` modifier.
`void`	`visitCtTextBlock(CtTextBlock e)`	Visits a literal TextBlock string.
`<T> void`	`visitCtThisAccess(CtThisAccess<T> e)`	Visits a this access.
`void`	`visitCtThrow(CtThrow e)`	Visits a `throw` statement.
`void`	`visitCtTry(CtTry e)`	Visits a `try` statement.
`void`	`visitCtTryWithResource(CtTryWithResource e)`	Visits a `try` with resource statement.
`<T> void`	`visitCtTypeAccess(CtTypeAccess<T> e)`	Visits a type access.
`void`	`visitCtTypeMemberWildcardImportReference(CtTypeMemberWildcardImportReference wildcardReference)`	Visits an import wildcard static type member reference
`void`	`visitCtTypeParameter(CtTypeParameter typeParameter)`	Visits a type parameter declaration.
`void`	`visitCtTypeParameterReference(CtTypeParameterReference e)`	Visits a reference to a type parameter.
`<T> void`	`visitCtTypeReference(CtTypeReference<T> e)`	Visits a reference to a type.
`<T> void`	`visitCtUnaryOperator(CtUnaryOperator<T> e)`	Visits a unary operator.
`<T> void`	`visitCtUnboundVariableReference(CtUnboundVariableReference<T> reference)`	Visits a reference to an unbound field
`void`	`visitCtUsedService(CtUsedService usedService)`	Visits a "uses" directive in a module declaration.
`<T> void`	`visitCtVariableRead(CtVariableRead<T> e)`	Visits a variable read access.
`<T> void`	`visitCtVariableWrite(CtVariableWrite<T> e)`	Visits a variable write access.
`void`	`visitCtWhile(CtWhile e)`	Visits a `while` loop.
`void`	`visitCtWildcardReference(CtWildcardReference wildcardReference)`	Visits a reference to a wildcard.
`void`	`visitCtYieldStatement(CtYieldStatement e)`	Visits a yield statement.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - CtInheritanceScanner
```
public CtInheritanceScanner()
```
    Default constructor.
- Method Detail
  - visitCtCodeSnippetExpression
```
public <T> void visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet expression.
    
    Specified by:
    
    visitCtCodeSnippetExpression in interface CtVisitor
  - visitCtCodeSnippetStatement
```
public void visitCtCodeSnippetStatement(CtCodeSnippetStatement e)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet statement.
    
    Specified by:
    
    visitCtCodeSnippetStatement in interface CtVisitor
  - scan
```
public void scan(Collection<? extends CtElement> elements)
```
    Generically scans a collection of meta-model elements.
  - scan
```
public void scan(CtElement element)
```
    Generically scans a meta-model element.
  - scanCtAbstractInvocation
```
public <T> void scanCtAbstractInvocation(CtAbstractInvocation<T> a)
```
    Scans an abstract invocation.
  - scanCtAbstractSwitch
```
public <S> void scanCtAbstractSwitch(CtAbstractSwitch<S> a)
```
    Scans an abstract switch (either switch statement or switch expression).
  - scanCtCFlowBreak
```
public void scanCtCFlowBreak(CtCFlowBreak flowBreak)
```
    Scans an abstract control flow break.
  - scanCtLabelledFlowBreak
```
public void scanCtLabelledFlowBreak(CtLabelledFlowBreak labelledFlowBreak)
```
    Scans a labelled control flow break.
  - scanCtCodeElement
```
public void scanCtCodeElement(CtCodeElement e)
```
    Scans an abstract code element.
  - scanCtTypeMember
```
public void scanCtTypeMember(CtTypeMember e)
```
  - scanCtModuleDirective
```
public void scanCtModuleDirective(CtModuleDirective e)
```
  - scanCtElement
```
public void scanCtElement(CtElement e)
```
    Scans an abstract element.
  - scanCtExecutable
```
public <R> void scanCtExecutable(CtExecutable<R> e)
```
    Scans an abstract executable.
  - scanCtExpression
```
public <T> void scanCtExpression(CtExpression<T> expression)
```
    Scans an abstract expression.
  - scanCtFormalTypeDeclarer
```
public void scanCtFormalTypeDeclarer(CtFormalTypeDeclarer e)
```
    Scans a formal type declarer.
  - scanCtVisitable
```
public void scanCtVisitable(CtVisitable e)
```
  - scanCtActualTypeContainer
```
public void scanCtActualTypeContainer(CtActualTypeContainer reference)
```
    Scans an actual type container..
  - scanCtLoop
```
public void scanCtLoop(CtLoop loop)
```
    Scans an abstract loop.
  - scanCtModifiable
```
public void scanCtModifiable(CtModifiable m)
```
    Scans an abstract modifiable element.
  - scanCtNamedElement
```
public void scanCtNamedElement(CtNamedElement e)
```
    Scans an abstract named element.
  - scanCtReference
```
public void scanCtReference(CtReference reference)
```
    Scans an abstract reference.
  - scanCtStatement
```
public void scanCtStatement(CtStatement s)
```
    Scans an abstract statement.
  - scanCtTargetedExpression
```
public <T,E extends CtExpression<?>> void scanCtTargetedExpression(CtTargetedExpression<T,E> targetedExpression)
```
    Scans an abstract targeted expression.
  - scanCtType
```
public <T> void scanCtType(CtType<T> type)
```
    Scans an abstract type.
  - scanCtTypedElement
```
public <T> void scanCtTypedElement(CtTypedElement<T> e)
```
    Scans an abstract typed element.
  - scanCtVariable
```
public <T> void scanCtVariable(CtVariable<T> v)
```
    Scans an abstract variable declaration.
  - scanCtArrayAccess
```
public <T,E extends CtExpression<?>> void scanCtArrayAccess(CtArrayAccess<T,E> arrayAccess)
```
    Scans an array access (read and write).
  - scanCtFieldAccess
```
public <T> void scanCtFieldAccess(CtFieldAccess<T> fieldAccess)
```
    Scans a field access (read and write).
  - scanCtVariableAccess
```
public <T> void scanCtVariableAccess(CtVariableAccess<T> variableAccess)
```
    Scans a variable access (read and write).
  - scanCtRHSReceiver
```
public <T> void scanCtRHSReceiver(CtRHSReceiver<T> ctRHSReceiver)
```
    Scans the right-hand side of an assignment
  - scanCtShadowable
```
public void scanCtShadowable(CtShadowable ctShadowable)
```
    Scans a shadowable element
  - scanCtBodyHolder
```
public void scanCtBodyHolder(CtBodyHolder ctBodyHolder)
```
    Scans a body holder
  - visitCtFieldRead
```
public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead)
```
    Description copied from interface: CtVisitor
    
    Visits a field read access.
    
    Specified by:
    
    visitCtFieldRead in interface CtVisitor
  - visitCtFieldWrite
```
public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a field write access.
    
    Specified by:
    
    visitCtFieldWrite in interface CtVisitor
  - visitCtSuperAccess
```
public <T> void visitCtSuperAccess(CtSuperAccess<T> f)
```
    Description copied from interface: CtVisitor
    
    Visits an access to a super invocation.
    
    Specified by:
    
    visitCtSuperAccess in interface CtVisitor
  - scanCtMultiTypedElement
```
public void scanCtMultiTypedElement(CtMultiTypedElement f)
```
  - visitCtOperatorAssignment
```
public <T,A extends T> void visitCtOperatorAssignment(CtOperatorAssignment<T,A> e)
```
    Description copied from interface: CtVisitor
    
    Visits an operator assignment.
    
    Specified by:
    
    visitCtOperatorAssignment in interface CtVisitor
  - scanCtVariableReference
```
public <T> void scanCtVariableReference(CtVariableReference<T> reference)
```
    Scans an abstract variable reference.
  - scanCtTypeInformation
```
public <T> void scanCtTypeInformation(CtTypeInformation typeInfo)
```
    Scans an abstract variable reference.
  - visitCtAnnotation
```
public <A extends Annotation> void visitCtAnnotation(CtAnnotation<A> e)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation.
    
    Specified by:
    
    visitCtAnnotation in interface CtVisitor
  - visitCtAnnotationType
```
public <A extends Annotation> void visitCtAnnotationType(CtAnnotationType<A> e)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation type declaration.
    
    Specified by:
    
    visitCtAnnotationType in interface CtVisitor
  - visitCtAnonymousExecutable
```
public void visitCtAnonymousExecutable(CtAnonymousExecutable e)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous executable.
    
    Specified by:
    
    visitCtAnonymousExecutable in interface CtVisitor
  - visitCtArrayRead
```
public <T> void visitCtArrayRead(CtArrayRead<T> arrayRead)
```
    Description copied from interface: CtVisitor
    
    Visits an array read access.
    
    Specified by:
    
    visitCtArrayRead in interface CtVisitor
  - visitCtArrayWrite
```
public <T> void visitCtArrayWrite(CtArrayWrite<T> arrayWrite)
```
    Description copied from interface: CtVisitor
    
    Visits an array write access.
    
    Specified by:
    
    visitCtArrayWrite in interface CtVisitor
  - visitCtArrayTypeReference
```
public <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an array type.
    
    Specified by:
    
    visitCtArrayTypeReference in interface CtVisitor
  - visitCtAssert
```
public <T> void visitCtAssert(CtAssert<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an assert.
    
    Specified by:
    
    visitCtAssert in interface CtVisitor
  - visitCtAssignment
```
public <T,A extends T> void visitCtAssignment(CtAssignment<T,A> e)
```
    Description copied from interface: CtVisitor
    
    Visits an assignment.
    
    Specified by:
    
    visitCtAssignment in interface CtVisitor
  - visitCtBinaryOperator
```
public <T> void visitCtBinaryOperator(CtBinaryOperator<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a binary operator.
    
    Specified by:
    
    visitCtBinaryOperator in interface CtVisitor
  - visitCtBlock
```
public <R> void visitCtBlock(CtBlock<R> e)
```
    Description copied from interface: CtVisitor
    
    Visits a block of code.
    
    Specified by:
    
    visitCtBlock in interface CtVisitor
  - visitCtBreak
```
public void visitCtBreak(CtBreak e)
```
    Description copied from interface: CtVisitor
    
    Visits a break statement.
    
    Specified by:
    
    visitCtBreak in interface CtVisitor
  - visitCtCase
```
public <E> void visitCtCase(CtCase<E> e)
```
    Description copied from interface: CtVisitor
    
    Visits a case clause.
    
    Specified by:
    
    visitCtCase in interface CtVisitor
  - visitCtCatch
```
public void visitCtCatch(CtCatch e)
```
    Description copied from interface: CtVisitor
    
    Visits a catch clause.
    
    Specified by:
    
    visitCtCatch in interface CtVisitor
  - visitCtClass
```
public <T> void visitCtClass(CtClass<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a class declaration.
    
    Specified by:
    
    visitCtClass in interface CtVisitor
  - visitCtTypeParameter
```
public void visitCtTypeParameter(CtTypeParameter typeParameter)
```
    Description copied from interface: CtVisitor
    
    Visits a type parameter declaration.
    
    Specified by:
    
    visitCtTypeParameter in interface CtVisitor
  - visitCtConditional
```
public <T> void visitCtConditional(CtConditional<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a conditional expression
    
    Specified by:
    
    visitCtConditional in interface CtVisitor
  - visitCtConstructor
```
public <T> void visitCtConstructor(CtConstructor<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a constructor declaration.
    
    Specified by:
    
    visitCtConstructor in interface CtVisitor
  - visitCtContinue
```
public void visitCtContinue(CtContinue e)
```
    Description copied from interface: CtVisitor
    
    Visits a continue statement.
    
    Specified by:
    
    visitCtContinue in interface CtVisitor
  - visitCtDo
```
public void visitCtDo(CtDo e)
```
    Description copied from interface: CtVisitor
    
    Visits a do loop.
    
    Specified by:
    
    visitCtDo in interface CtVisitor
  - visitCtEnum
```
public <T extends Enum<?>> void visitCtEnum(CtEnum<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an enumeration declaration.
    
    Specified by:
    
    visitCtEnum in interface CtVisitor
  - visitCtExecutableReference
```
public <T> void visitCtExecutableReference(CtExecutableReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an executable.
    
    Specified by:
    
    visitCtExecutableReference in interface CtVisitor
  - visitCtField
```
public <T> void visitCtField(CtField<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a field declaration.
    
    Specified by:
    
    visitCtField in interface CtVisitor
  - visitCtEnumValue
```
public <T> void visitCtEnumValue(CtEnumValue<T> enumValue)
```
    Description copied from interface: CtVisitor
    
    Visits an enum value declaration.
    
    Specified by:
    
    visitCtEnumValue in interface CtVisitor
  - visitCtThisAccess
```
public <T> void visitCtThisAccess(CtThisAccess<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a this access.
    
    Specified by:
    
    visitCtThisAccess in interface CtVisitor
  - visitCtFieldReference
```
public <T> void visitCtFieldReference(CtFieldReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a field.
    
    Specified by:
    
    visitCtFieldReference in interface CtVisitor
  - visitCtFor
```
public void visitCtFor(CtFor e)
```
    Description copied from interface: CtVisitor
    
    Visits a for loop.
    
    Specified by:
    
    visitCtFor in interface CtVisitor
  - visitCtForEach
```
public void visitCtForEach(CtForEach e)
```
    Description copied from interface: CtVisitor
    
    Visits an enhanced for loop.
    
    Specified by:
    
    visitCtForEach in interface CtVisitor
  - visitCtIf
```
public void visitCtIf(CtIf e)
```
    Description copied from interface: CtVisitor
    
    Visits an if statement.
    
    Specified by:
    
    visitCtIf in interface CtVisitor
  - visitCtInterface
```
public <T> void visitCtInterface(CtInterface<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an interface declaration.
    
    Specified by:
    
    visitCtInterface in interface CtVisitor
  - visitCtInvocation
```
public <T> void visitCtInvocation(CtInvocation<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an executable invocation.
    
    Specified by:
    
    visitCtInvocation in interface CtVisitor
  - visitCtLiteral
```
public <T> void visitCtLiteral(CtLiteral<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a literal expression.
    
    Specified by:
    
    visitCtLiteral in interface CtVisitor
  - visitCtTextBlock
```
public void visitCtTextBlock(CtTextBlock e)
```
    Description copied from interface: CtVisitor
    
    Visits a literal TextBlock string.
    
    Specified by:
    
    visitCtTextBlock in interface CtVisitor
  - visitCtLocalVariable
```
public <T> void visitCtLocalVariable(CtLocalVariable<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a local variable declaration.
    
    Specified by:
    
    visitCtLocalVariable in interface CtVisitor
  - visitCtLocalVariableReference
```
public <T> void visitCtLocalVariableReference(CtLocalVariableReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a local variable.
    
    Specified by:
    
    visitCtLocalVariableReference in interface CtVisitor
  - visitCtCatchVariable
```
public <T> void visitCtCatchVariable(CtCatchVariable<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a catch variable declaration.
    
    Specified by:
    
    visitCtCatchVariable in interface CtVisitor
  - visitCtCatchVariableReference
```
public <T> void visitCtCatchVariableReference(CtCatchVariableReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a catch variable.
    
    Specified by:
    
    visitCtCatchVariableReference in interface CtVisitor
  - visitCtMethod
```
public <T> void visitCtMethod(CtMethod<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a method declaration.
    
    Specified by:
    
    visitCtMethod in interface CtVisitor
  - visitCtAnnotationMethod
```
public <T> void visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation method declaration.
    
    Specified by:
    
    visitCtAnnotationMethod in interface CtVisitor
  - visitCtNewArray
```
public <T> void visitCtNewArray(CtNewArray<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an array construction.
    
    Specified by:
    
    visitCtNewArray in interface CtVisitor
  - visitCtConstructorCall
```
public <T> void visitCtConstructorCall(CtConstructorCall<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a call to a constructor.
    
    Specified by:
    
    visitCtConstructorCall in interface CtVisitor
  - visitCtNewClass
```
public <T> void visitCtNewClass(CtNewClass<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous class construction.
    
    Specified by:
    
    visitCtNewClass in interface CtVisitor
  - visitCtLambda
```
public <T> void visitCtLambda(CtLambda<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous method construction.
    
    Specified by:
    
    visitCtLambda in interface CtVisitor
  - visitCtExecutableReferenceExpression
```
public <T,E extends CtExpression<?>> void visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an executable.
    
    Specified by:
    
    visitCtExecutableReferenceExpression in interface CtVisitor
  - visitCtOperatorAssignement
```
public <T,A extends T> void visitCtOperatorAssignement(CtOperatorAssignment<T,A> assignment)
```
  - visitCtPackage
```
public void visitCtPackage(CtPackage e)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration.
    
    Specified by:
    
    visitCtPackage in interface CtVisitor
  - visitCtPackageReference
```
public void visitCtPackageReference(CtPackageReference e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a package.
    
    Specified by:
    
    visitCtPackageReference in interface CtVisitor
  - visitCtParameter
```
public <T> void visitCtParameter(CtParameter<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a parameter declaration.
    
    Specified by:
    
    visitCtParameter in interface CtVisitor
  - visitCtParameterReference
```
public <T> void visitCtParameterReference(CtParameterReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a parameter.
    
    Specified by:
    
    visitCtParameterReference in interface CtVisitor
  - visitCtReturn
```
public <R> void visitCtReturn(CtReturn<R> e)
```
    Description copied from interface: CtVisitor
    
    Visits a return statement.
    
    Specified by:
    
    visitCtReturn in interface CtVisitor
  - visitCtStatementList
```
public <R> void visitCtStatementList(CtStatementList e)
```
    Description copied from interface: CtVisitor
    
    Visits a statement list.
    
    Specified by:
    
    visitCtStatementList in interface CtVisitor
  - visitCtSwitch
```
public <E> void visitCtSwitch(CtSwitch<E> e)
```
    Description copied from interface: CtVisitor
    
    Visits a switch statement.
    
    Specified by:
    
    visitCtSwitch in interface CtVisitor
  - visitCtSwitchExpression
```
public <T,S> void visitCtSwitchExpression(CtSwitchExpression<T,S> e)
```
    Description copied from interface: CtVisitor
    
    Visits a switch expression.
    
    Specified by:
    
    visitCtSwitchExpression in interface CtVisitor
  - visitCtSynchronized
```
public void visitCtSynchronized(CtSynchronized e)
```
    Description copied from interface: CtVisitor
    
    Visits a synchronized modifier.
    
    Specified by:
    
    visitCtSynchronized in interface CtVisitor
  - visitCtThrow
```
public void visitCtThrow(CtThrow e)
```
    Description copied from interface: CtVisitor
    
    Visits a throw statement.
    
    Specified by:
    
    visitCtThrow in interface CtVisitor
  - visitCtTry
```
public void visitCtTry(CtTry e)
```
    Description copied from interface: CtVisitor
    
    Visits a try statement.
    
    Specified by:
    
    visitCtTry in interface CtVisitor
  - visitCtTryWithResource
```
public void visitCtTryWithResource(CtTryWithResource e)
```
    Description copied from interface: CtVisitor
    
    Visits a try with resource statement.
    
    Specified by:
    
    visitCtTryWithResource in interface CtVisitor
  - visitCtTypeParameterReference
```
public void visitCtTypeParameterReference(CtTypeParameterReference e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type parameter.
    
    Specified by:
    
    visitCtTypeParameterReference in interface CtVisitor
  - visitCtWildcardReference
```
public void visitCtWildcardReference(CtWildcardReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a wildcard.
    
    Specified by:
    
    visitCtWildcardReference in interface CtVisitor
  - visitCtIntersectionTypeReference
```
public <T> void visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits an intersection type.
    
    Specified by:
    
    visitCtIntersectionTypeReference in interface CtVisitor
  - visitCtTypeReference
```
public <T> void visitCtTypeReference(CtTypeReference<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type.
    
    Specified by:
    
    visitCtTypeReference in interface CtVisitor
  - visitCtTypeAccess
```
public <T> void visitCtTypeAccess(CtTypeAccess<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a type access.
    
    Specified by:
    
    visitCtTypeAccess in interface CtVisitor
  - visitCtUnaryOperator
```
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a unary operator.
    
    Specified by:
    
    visitCtUnaryOperator in interface CtVisitor
  - visitCtVariableRead
```
public <T> void visitCtVariableRead(CtVariableRead<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a variable read access.
    
    Specified by:
    
    visitCtVariableRead in interface CtVisitor
  - visitCtVariableWrite
```
public <T> void visitCtVariableWrite(CtVariableWrite<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a variable write access.
    
    Specified by:
    
    visitCtVariableWrite in interface CtVisitor
  - visitCtComment
```
public void visitCtComment(CtComment e)
```
    Description copied from interface: CtVisitor
    
    Visits a comment
    
    Specified by:
    
    visitCtComment in interface CtVisitor
  - visitCtJavaDoc
```
public void visitCtJavaDoc(CtJavaDoc e)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc comment
    
    Specified by:
    
    visitCtJavaDoc in interface CtVisitor
  - visitCtJavaDocTag
```
public void visitCtJavaDocTag(CtJavaDocTag e)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc tag
    
    Specified by:
    
    visitCtJavaDocTag in interface CtVisitor
  - visitCtAnnotationFieldAccess
```
public <T> void visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> e)
```
    Description copied from interface: CtVisitor
    
    Visits a field of an annotation.
    
    Specified by:
    
    visitCtAnnotationFieldAccess in interface CtVisitor
  - visitCtWhile
```
public void visitCtWhile(CtWhile e)
```
    Description copied from interface: CtVisitor
    
    Visits a while loop.
    
    Specified by:
    
    visitCtWhile in interface CtVisitor
  - visitCtUnboundVariableReference
```
public <T> void visitCtUnboundVariableReference(CtUnboundVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an unbound field
    
    Specified by:
    
    visitCtUnboundVariableReference in interface CtVisitor
  - scanCtCodeSnippet
```
public void scanCtCodeSnippet(CtCodeSnippet snippet)
```
  - visitCtImport
```
public void visitCtImport(CtImport ctImport)
```
    Description copied from interface: CtVisitor
    
    Visits an import declaration
    
    Specified by:
    
    visitCtImport in interface CtVisitor
  - visitCtModule
```
public void visitCtModule(CtModule module)
```
    Description copied from interface: CtVisitor
    
    Visits a module declaration
    
    Specified by:
    
    visitCtModule in interface CtVisitor
  - visitCtModuleReference
```
public void visitCtModuleReference(CtModuleReference moduleReference)
```
    Description copied from interface: CtVisitor
    
    Visits a module reference
    
    Specified by:
    
    visitCtModuleReference in interface CtVisitor
  - visitCtPackageExport
```
public void visitCtPackageExport(CtPackageExport moduleExport)
```
    Description copied from interface: CtVisitor
    
    Visits a package export in a module declaration.
    
    Specified by:
    
    visitCtPackageExport in interface CtVisitor
  - visitCtModuleRequirement
```
public void visitCtModuleRequirement(CtModuleRequirement moduleRequirement)
```
    Description copied from interface: CtVisitor
    
    Visits a "require" directive in a module declaration.
    
    Specified by:
    
    visitCtModuleRequirement in interface CtVisitor
  - visitCtProvidedService
```
public void visitCtProvidedService(CtProvidedService moduleProvidedService)
```
    Description copied from interface: CtVisitor
    
    Visits a "provides" directive in a module declaration.
    
    Specified by:
    
    visitCtProvidedService in interface CtVisitor
  - visitCtUsedService
```
public void visitCtUsedService(CtUsedService usedService)
```
    Description copied from interface: CtVisitor
    
    Visits a "uses" directive in a module declaration.
    
    Specified by:
    
    visitCtUsedService in interface CtVisitor
  - visitCtCompilationUnit
```
public void visitCtCompilationUnit(CtCompilationUnit compilationUnit)
```
    Description copied from interface: CtVisitor
    
    Visits a compilation unit
    
    Specified by:
    
    visitCtCompilationUnit in interface CtVisitor
  - visitCtPackageDeclaration
```
public void visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration
    
    Specified by:
    
    visitCtPackageDeclaration in interface CtVisitor
  - visitCtTypeMemberWildcardImportReference
```
public void visitCtTypeMemberWildcardImportReference(CtTypeMemberWildcardImportReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits an import wildcard static type member reference
    
    Specified by:
    
    visitCtTypeMemberWildcardImportReference in interface CtVisitor
  - visitCtYieldStatement
```
public void visitCtYieldStatement(CtYieldStatement e)
```
    Description copied from interface: CtVisitor
    
    Visits a yield statement.
    
    Specified by:
    
    visitCtYieldStatement in interface CtVisitor

Class CtInheritanceScanner

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CtInheritanceScanner

Method Detail

visitCtCodeSnippetExpression

visitCtCodeSnippetStatement

scan

scan

scanCtAbstractInvocation

scanCtAbstractSwitch

scanCtCFlowBreak

scanCtLabelledFlowBreak

scanCtCodeElement

scanCtTypeMember

scanCtModuleDirective

scanCtElement

scanCtExecutable

scanCtExpression

scanCtFormalTypeDeclarer

scanCtVisitable

scanCtActualTypeContainer

scanCtLoop

scanCtModifiable

scanCtNamedElement

scanCtReference

scanCtStatement

scanCtTargetedExpression

scanCtType

scanCtTypedElement

scanCtVariable

scanCtArrayAccess

scanCtFieldAccess

scanCtVariableAccess

scanCtRHSReceiver

scanCtShadowable

scanCtBodyHolder

visitCtFieldRead

visitCtFieldWrite

visitCtSuperAccess

scanCtMultiTypedElement

visitCtOperatorAssignment

scanCtVariableReference

scanCtTypeInformation

visitCtAnnotation

visitCtAnnotationType

visitCtAnonymousExecutable

visitCtArrayRead

visitCtArrayWrite

visitCtArrayTypeReference

visitCtAssert

visitCtAssignment

visitCtBinaryOperator

visitCtBlock

visitCtBreak

visitCtCase

visitCtCatch

visitCtClass

visitCtTypeParameter

visitCtConditional

visitCtConstructor

visitCtContinue

visitCtDo

visitCtEnum

visitCtExecutableReference

visitCtField

visitCtEnumValue

visitCtThisAccess

visitCtFieldReference

visitCtFor

visitCtForEach

visitCtIf

visitCtInterface

visitCtInvocation

visitCtLiteral

visitCtTextBlock

visitCtLocalVariable

visitCtLocalVariableReference