CtScanner.java

/**
 * Copyright (C) 2006-2016 INRIA and contributors
 * Spoon - http://spoon.gforge.inria.fr/
 *
 * This software is governed by the CeCILL-C License under French law and
 * abiding by the rules of distribution of free software. You can use, modify
 * and/or redistribute the software under the terms of the CeCILL-C license as
 * circulated by CEA, CNRS and INRIA at http://www.cecill.info.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-C license and that you accept its terms.
 */
package spoon.reflect.visitor;

import spoon.reflect.code.CtAnnotationFieldAccess;
import spoon.reflect.code.CtArrayRead;
import spoon.reflect.code.CtArrayWrite;
import spoon.reflect.code.CtAssert;
import spoon.reflect.code.CtAssignment;
import spoon.reflect.code.CtBinaryOperator;
import spoon.reflect.code.CtBlock;
import spoon.reflect.code.CtBreak;
import spoon.reflect.code.CtCase;
import spoon.reflect.code.CtCatch;
import spoon.reflect.code.CtCatchVariable;
import spoon.reflect.code.CtCodeSnippetExpression;
import spoon.reflect.code.CtCodeSnippetStatement;
import spoon.reflect.code.CtComment;
import spoon.reflect.code.CtConditional;
import spoon.reflect.code.CtConstructorCall;
import spoon.reflect.code.CtContinue;
import spoon.reflect.code.CtDo;
import spoon.reflect.code.CtExecutableReferenceExpression;
import spoon.reflect.code.CtExpression;
import spoon.reflect.code.CtFieldRead;
import spoon.reflect.code.CtFieldWrite;
import spoon.reflect.code.CtFor;
import spoon.reflect.code.CtForEach;
import spoon.reflect.code.CtIf;
import spoon.reflect.code.CtInvocation;
import spoon.reflect.code.CtLambda;
import spoon.reflect.code.CtLiteral;
import spoon.reflect.code.CtLocalVariable;
import spoon.reflect.code.CtNewArray;
import spoon.reflect.code.CtNewClass;
import spoon.reflect.code.CtOperatorAssignment;
import spoon.reflect.code.CtReturn;
import spoon.reflect.code.CtStatement;
import spoon.reflect.code.CtStatementList;
import spoon.reflect.code.CtSuperAccess;
import spoon.reflect.code.CtSwitch;
import spoon.reflect.code.CtSynchronized;
import spoon.reflect.code.CtThisAccess;
import spoon.reflect.code.CtThrow;
import spoon.reflect.code.CtTry;
import spoon.reflect.code.CtTryWithResource;
import spoon.reflect.code.CtTypeAccess;
import spoon.reflect.code.CtUnaryOperator;
import spoon.reflect.code.CtVariableRead;
import spoon.reflect.code.CtVariableWrite;
import spoon.reflect.code.CtWhile;
import spoon.reflect.declaration.CtAnnotation;
import spoon.reflect.declaration.CtAnnotationMethod;
import spoon.reflect.declaration.CtAnnotationType;
import spoon.reflect.declaration.CtAnonymousExecutable;
import spoon.reflect.declaration.CtClass;
import spoon.reflect.declaration.CtConstructor;
import spoon.reflect.declaration.CtElement;
import spoon.reflect.declaration.CtEnum;
import spoon.reflect.declaration.CtEnumValue;
import spoon.reflect.declaration.CtField;
import spoon.reflect.declaration.CtInterface;
import spoon.reflect.declaration.CtMethod;
import spoon.reflect.declaration.CtPackage;
import spoon.reflect.declaration.CtParameter;
import spoon.reflect.declaration.CtTypeParameter;
import spoon.reflect.reference.CtArrayTypeReference;
import spoon.reflect.reference.CtCatchVariableReference;
import spoon.reflect.reference.CtExecutableReference;
import spoon.reflect.reference.CtFieldReference;
import spoon.reflect.reference.CtIntersectionTypeReference;
import spoon.reflect.reference.CtLocalVariableReference;
import spoon.reflect.reference.CtPackageReference;
import spoon.reflect.reference.CtParameterReference;
import spoon.reflect.reference.CtTypeParameterReference;
import spoon.reflect.reference.CtTypeReference;
import spoon.reflect.reference.CtUnboundVariableReference;
import spoon.reflect.reference.CtWildcardReference;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * This visitor implements a deep-search scan on the model.
 *
 * Ensures that all children nodes are visited once, a visit means three method
 * calls, one call to "enter", one call to "exit" and one call to scan.
 *
 * Is used by the processing and filtering engine.
 */
public abstract class CtScanner implements CtVisitor {
	/**
	 * Default constructor.
	 */
	public CtScanner() {
		super();
	}

	/**
	 * This method is upcalled by the scanner when entering a scanned element.
	 * To be overridden to implement specific scanners.
	 */
	protected void enter(CtElement e) {
		System.out.println("CtScanner.enter() :: " + e.getClass() + " :: " + e.getShortRepresentation());
	}

	/**
	 * This method is upcalled by the scanner when exiting a scanned element. To
	 * be overridden to implement specific scanners.
	 */
	protected void exit(CtElement e) {
	}

	/**
	 * Generically scans a collection of meta-model elements.
	 */
	public void scan(Collection<? extends CtElement> elements) {
		if ((elements != null)) {
			// we use defensive copy so as to be able to change the class while scanning
			// otherwise one gets a ConcurrentModificationException
			for (CtElement e : new ArrayList<>(elements)) {
				scan(e);
			}
		}

	}

	/**
	 * Generically scans a meta-model element.
	 */
	public void scan(CtElement element) {
		if ((element != null)) {
			System.out.println("CtScanner.scan()" + element.toString());
			element.accept(this);
		}
	}

	public <A extends Annotation> void visitCtAnnotation(
			final CtAnnotation<A> annotation) {
		enter(annotation);
		scan(annotation.getType());
		scan(annotation.getComments());
		scan(annotation.getAnnotationType());
		scan(annotation.getAnnotations());
		scan(annotation.getValues());
		exit(annotation);
	}

	/**
	 * Generically scans an object that can be an element, a reference, or a
	 * collection of those.
	 */
	public void scan(Object o) {
		if (o instanceof CtElement) {
			scan((CtElement) o);
		}
		if (o instanceof Collection<?>) {
			for (Object obj : (Collection<?>) o) {
				scan(obj);
			}
		}
		if (o instanceof Map<?, ?>) {
			for (Object obj : ((Map) o).values()) {
				scan(obj);
			}
		}
	}

	public <A extends Annotation> void visitCtAnnotationType(
			final CtAnnotationType<A> annotationType) {
		enter(annotationType);
		scan(annotationType.getAnnotations());
		scan(annotationType.getTypeMembers());
		scan(annotationType.getComments());
		exit(annotationType);
	}

	public void visitCtAnonymousExecutable(final CtAnonymousExecutable anonymousExec) {
		enter(anonymousExec);
		scan(anonymousExec.getAnnotations());
		scan(anonymousExec.getBody());
		scan(anonymousExec.getComments());
		exit(anonymousExec);
	}

	@Override
	public <T> void visitCtArrayRead(final CtArrayRead<T> arrayRead) {
		enter(arrayRead);
		scan(arrayRead.getAnnotations());
		scan(arrayRead.getType());
		scan(arrayRead.getTypeCasts());
		scan(arrayRead.getTarget());
		scan(arrayRead.getIndexExpression());
		scan(arrayRead.getComments());
		exit(arrayRead);
	}

	@Override
	public <T> void visitCtArrayWrite(final CtArrayWrite<T> arrayWrite) {
		enter(arrayWrite);
		scan(arrayWrite.getAnnotations());
		scan(arrayWrite.getType());
		scan(arrayWrite.getTypeCasts());
		scan(arrayWrite.getTarget());
		scan(arrayWrite.getIndexExpression());
		scan(arrayWrite.getComments());
		exit(arrayWrite);
	}

	public <T> void visitCtArrayTypeReference(final CtArrayTypeReference<T> reference) {
		enter(reference);
		scan(reference.getComments());
		scan(reference.getPackage());
		scan(reference.getDeclaringType());
		scan(reference.getComponentType());
		scan(reference.getActualTypeArguments());
		scan(reference.getAnnotations());
		exit(reference);
	}

	public <T> void visitCtAssert(final CtAssert<T> asserted) {
		enter(asserted);
		scan(asserted.getAnnotations());
		scan(asserted.getAssertExpression());
		scan(asserted.getExpression());
		scan(asserted.getComments());
		exit(asserted);
	}

	// I believe this is what we need for our CSV
	public <T, A extends T> void visitCtAssignment(
			final CtAssignment<T, A> assignement) {
		System.out.println("CtScanner.visitCtAssignment()" + assignement);
		enter(assignement);
		scan(assignement.getAnnotations());
		scan(assignement.getType());
		scan(assignement.getTypeCasts());
		scan(assignement.getAssigned());
		List<CtVariableRead> elements = assignement.getAssignment().getElements(new spoon.reflect.visitor.filter.TypeFilter<>(spoon.reflect.code.CtVariableRead.class));
		System.err.println("CtScanner.visitCtAssignment()\tassigned\t" + assignement.getAssigned().toString());
		//System.err.println("CtScanner.visitCtAssignment()\tassignment\t" + assignement.getAssignment().toString());
		System.err.println("CtScanner.visitCtAssignment()\tassignment elements\t" + elements);
		scan(assignement.getAssignment());
		scan(assignement.getComments());
		exit(assignement);
	}

	public <T> void visitCtBinaryOperator(final CtBinaryOperator<T> operator) {
		enter(operator);
		scan(operator.getAnnotations());
		scan(operator.getType());
		scan(operator.getTypeCasts());
		scan(operator.getLeftHandOperand());
		scan(operator.getRightHandOperand());
		scan(operator.getComments());
		exit(operator);
	}

	public <R> void visitCtBlock(final CtBlock<R> block) {
		enter(block);
		scan(block.getAnnotations());
		scan(block.getStatements());
		scan(block.getComments());
		exit(block);
	}

	public void visitCtBreak(final CtBreak breakStatement) {
		enter(breakStatement);
		scan(breakStatement.getAnnotations());
		scan(breakStatement.getComments());
		exit(breakStatement);
	}

	public <S> void visitCtCase(final CtCase<S> caseStatement) {
		enter(caseStatement);
		scan(caseStatement.getAnnotations());
		scan(caseStatement.getCaseExpression());
		scan(caseStatement.getStatements());
		scan(caseStatement.getComments());
		exit(caseStatement);
	}

	public void visitCtCatch(final CtCatch catchBlock) {
		enter(catchBlock);
		scan(catchBlock.getAnnotations());
		scan(catchBlock.getParameter());
		scan(catchBlock.getBody());
		scan(catchBlock.getComments());
		exit(catchBlock);
	}

	public <T> void visitCtClass(final CtClass<T> ctClass) {
		enter(ctClass);
		scan(ctClass.getAnnotations());
		scan(ctClass.getSuperclass());
		scan(ctClass.getSuperInterfaces());
		scan(ctClass.getFormalCtTypeParameters());
		scan(ctClass.getTypeMembers());
		scan(ctClass.getComments());
		exit(ctClass);
	}

	@Override
	public void visitCtTypeParameter(CtTypeParameter typeParameter) {
		enter(typeParameter);
		scan(typeParameter.getAnnotations());
		scan(typeParameter.getSuperclass());
		scan(typeParameter.getComments());
		exit(typeParameter);
	}

	public <T> void visitCtConditional(final CtConditional<T> conditional) {
		enter(conditional);
		scan(conditional.getType());
		scan(conditional.getAnnotations());
		scan(conditional.getCondition());
		scan(conditional.getThenExpression());
		scan(conditional.getElseExpression());
		scan(conditional.getComments());
		scan(conditional.getTypeCasts());
		exit(conditional);
	}

	public <T> void visitCtConstructor(final CtConstructor<T> c) {
		enter(c);
		scan(c.getAnnotations());
		scan(c.getParameters());
		scan(c.getThrownTypes());
		scan(c.getFormalCtTypeParameters());
		scan(c.getBody());
		scan(c.getComments());
		exit(c);
	}

	public void visitCtContinue(final CtContinue continueStatement) {
		enter(continueStatement);
		scan(continueStatement.getAnnotations());
		scan(continueStatement.getLabelledStatement());
		scan(continueStatement.getComments());
		exit(continueStatement);
	}

	public void visitCtDo(final CtDo doLoop) {
		enter(doLoop);
		scan(doLoop.getAnnotations());
		scan(doLoop.getLoopingExpression());
		scan(doLoop.getBody());
		scan(doLoop.getComments());
		exit(doLoop);
	}

	public <T extends Enum<?>> void visitCtEnum(final CtEnum<T> ctEnum) {
		enter(ctEnum);
		scan(ctEnum.getAnnotations());
		scan(ctEnum.getSuperInterfaces());
		scan(ctEnum.getTypeMembers());
		scan(ctEnum.getEnumValues());
		scan(ctEnum.getComments());
		exit(ctEnum);
	}

	public <T> void visitCtExecutableReference(
			final CtExecutableReference<T> reference) {
		enter(reference);
		scan(reference.getDeclaringType());
		scan(reference.getType());
		scan(reference.getParameters());
		scan(reference.getActualTypeArguments());
		scan(reference.getAnnotations());
		scan(reference.getComments());
		exit(reference);
	}

	public <T> void visitCtField(final CtField<T> f) {
		enter(f);
		scan(f.getAnnotations());
		scan(f.getType());
		scan(f.getDefaultExpression());
		scan(f.getComments());
		exit(f);
	}

	@Override
	public <T> void visitCtEnumValue(final CtEnumValue<T> enumValue) {
		enter(enumValue);
		scan(enumValue.getAnnotations());
		scan(enumValue.getType());
		scan(enumValue.getDefaultExpression());
		scan(enumValue.getComments());
		exit(enumValue);
	}

	@Override
	public <T> void visitCtThisAccess(final CtThisAccess<T> thisAccess) {
		enter(thisAccess);
		scan(thisAccess.getComments());
		scan(thisAccess.getAnnotations());
		scan(thisAccess.getType());
		scan(thisAccess.getTypeCasts());
		scan(thisAccess.getTarget());
		exit(thisAccess);
	}

	public <T> void visitCtAnnotationFieldAccess(
			final CtAnnotationFieldAccess<T> annotationFieldAccess) {
		enter(annotationFieldAccess);
		scan(annotationFieldAccess.getComments());
		scan(annotationFieldAccess.getAnnotations());
		scan(annotationFieldAccess.getTypeCasts());
		scan(annotationFieldAccess.getTarget());
		scan(annotationFieldAccess.getType());
		scan(annotationFieldAccess.getVariable());
		exit(annotationFieldAccess);
	}

	public <T> void visitCtFieldReference(final CtFieldReference<T> reference) {
		enter(reference);
		scan(reference.getDeclaringType());
		scan(reference.getType());
		scan(reference.getAnnotations());
		exit(reference);
	}

	public void visitCtFor(final CtFor forLoop) {
		enter(forLoop);
		scan(forLoop.getAnnotations());
		scan(forLoop.getForInit());
		scan(forLoop.getExpression());
		scan(forLoop.getForUpdate());
		scan(forLoop.getBody());
		scan(forLoop.getComments());
		exit(forLoop);
	}

	public void visitCtForEach(final CtForEach foreach) {
		enter(foreach);
		scan(foreach.getAnnotations());
		scan(foreach.getVariable());
		scan(foreach.getExpression());
		scan(foreach.getBody());
		scan(foreach.getComments());
		exit(foreach);
	}

	public void visitCtIf(final CtIf ifElement) {
		enter(ifElement);
		scan(ifElement.getAnnotations());
		scan(ifElement.getCondition());
		scan((CtStatement) ifElement.getThenStatement());
		scan((CtStatement) ifElement.getElseStatement());
		scan(ifElement.getComments());
		exit(ifElement);
	}

	public <T> void visitCtInterface(final CtInterface<T> intrface) {
		enter(intrface);
		scan(intrface.getAnnotations());
		scan(intrface.getSuperInterfaces());
		scan(intrface.getFormalCtTypeParameters());
		scan(intrface.getTypeMembers());
		scan(intrface.getComments());
		exit(intrface);
	}

	public <T> void visitCtInvocation(final CtInvocation<T> invocation) {
		enter(invocation);
		scan(invocation.getAnnotations());
		scan(invocation.getTypeCasts());
		System.err.println("CtScanner.visitCtInvocation()\tinvocation target\t" + invocation.getTarget());
		scan(invocation.getTarget());
		scan(invocation.getExecutable());
		System.err.println("CtScanner.visitCtInvocation()\tinvocation executable\t" + invocation.getExecutable());
		scan(invocation.getArguments());
		System.err.println("CtScanner.visitCtInvocation()\tinvocation arguments\t" + invocation.getArguments());
		System.err.println("CtScanner.visitCtInvocation()\tinvocation arguments\t" + invocation.getArguments().size());
		for (Object o : invocation.getArguments()) {
			System.err.println("CtScanner.visitCtInvocation()\tinvocation arguments\t"
					+ o.getClass() + "\t" + o.toString());
		}
		scan(invocation.getComments());
		exit(invocation);
	}

	public <T> void visitCtLiteral(final CtLiteral<T> literal) {
		System.out.println("CtScanner.visitCtLiteral()" + literal.toString());
		enter(literal);
		scan(literal.getAnnotations());
		scan(literal.getType());
		scan(literal.getTypeCasts());
		scan(literal.getComments());
		exit(literal);
	}

	public <T> void visitCtLocalVariable(final CtLocalVariable<T> localVariable) {
		System.out.println("CtScanner.visitCtLocalVariable() " + localVariable.toString());
		System.err.println("CtScanner.visitCtLocalVariable() " + localVariable.getSimpleName());
		enter(localVariable);
		scan(localVariable.getAnnotations());
		scan(localVariable.getType());
		scan(localVariable.getDefaultExpression());
		scan(localVariable.getComments());
		exit(localVariable);
	}

	public <T> void visitCtLocalVariableReference(
			final CtLocalVariableReference<T> reference) {
		System.out.println("CtScanner.visitCtLocalVariableReference()" + reference.toString());
		System.err.println("CtScanner.visitCtLocalVariableReference()" + reference.getSimpleName());
		enter(reference);
		scan(reference.getType());
		scan(reference.getAnnotations());
		exit(reference);
	}

	public <T> void visitCtCatchVariable(final CtCatchVariable<T> catchVariable) {
		enter(catchVariable);
		scan(catchVariable.getComments());
		scan(catchVariable.getAnnotations());
		scan(catchVariable.getDefaultExpression());
		scan(catchVariable.getType());
		scan(catchVariable.getMultiTypes());
		exit(catchVariable);
	}

	public <T> void visitCtCatchVariableReference(final CtCatchVariableReference<T> reference) {
		enter(reference);
		scan(reference.getComments());
		scan(reference.getType());
		scan(reference.getAnnotations());
		exit(reference);
	}

	public <T> void visitCtMethod(final CtMethod<T> m) {
		enter(m);
		scan(m.getAnnotations());
		scan(m.getFormalCtTypeParameters());
		scan(m.getType());
		scan(m.getParameters());
		scan(m.getThrownTypes());
//		System.out.println("CtScanner.visitCtMethod()" + m.getBody().toString());
		scan(m.getBody());
		scan(m.getComments());
		exit(m);
	}

	@Override
	public <T> void visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod) {
		enter(annotationMethod);
		scan(annotationMethod.getAnnotations());
		scan(annotationMethod.getType());
		scan(annotationMethod.getDefaultExpression());
		scan(annotationMethod.getComments());
		exit(annotationMethod);
	}

	public <T> void visitCtNewArray(final CtNewArray<T> newArray) {
		enter(newArray);
		scan(newArray.getAnnotations());
		scan(newArray.getType());
		scan(newArray.getTypeCasts());
		scan(newArray.getElements());
		scan(newArray.getDimensionExpressions());
		scan(newArray.getComments());
		exit(newArray);
	}

	@Override
	public <T> void visitCtConstructorCall(final CtConstructorCall<T> ctConstructorCall) {
		enter(ctConstructorCall);
		scan(ctConstructorCall.getAnnotations());
		scan(ctConstructorCall.getTypeCasts());
		scan(ctConstructorCall.getExecutable());
		scan(ctConstructorCall.getTarget());
		scan(ctConstructorCall.getArguments());
		scan(ctConstructorCall.getComments());
		exit(ctConstructorCall);
	}

	public <T> void visitCtNewClass(final CtNewClass<T> newClass) {
		enter(newClass);
		scan(newClass.getAnnotations());
		scan(newClass.getTypeCasts());
		scan(newClass.getExecutable());
		scan(newClass.getTarget());
		scan(newClass.getArguments());
		scan(newClass.getAnonymousClass());
		scan(newClass.getComments());
		exit(newClass);
	}

	@Override
	public <T> void visitCtLambda(final CtLambda<T> lambda) {
		enter(lambda);
		scan(lambda.getAnnotations());
		scan(lambda.getType());
		scan(lambda.getTypeCasts());
		scan(lambda.getParameters());
		scan(lambda.getThrownTypes());
		scan(lambda.getBody());
		scan(lambda.getExpression());
		scan(lambda.getComments());
		exit(lambda);
	}

	@Override
	public <T, E extends CtExpression<?>> void visitCtExecutableReferenceExpression(
			final CtExecutableReferenceExpression<T, E> expression) {
		enter(expression);
		scan(expression.getComments());
		scan(expression.getAnnotations());
		scan(expression.getType());
		scan(expression.getTypeCasts());
		scan(expression.getExecutable());
		scan(expression.getTarget());
		exit(expression);
	}

	public <T, A extends T> void visitCtOperatorAssignment(
			final CtOperatorAssignment<T, A> assignment) {
		enter(assignment);
		scan(assignment.getAnnotations());
		scan(assignment.getType());
		scan(assignment.getTypeCasts());
		scan(assignment.getAssigned());
		scan(assignment.getAssignment());
		scan(assignment.getComments());
		exit(assignment);
	}

	public void visitCtPackage(final CtPackage ctPackage) {
		enter(ctPackage);
		scan(ctPackage.getAnnotations());
		scan(ctPackage.getPackages());
		scan(ctPackage.getTypes());
		scan(ctPackage.getComments());
		exit(ctPackage);
	}

	public void visitCtPackageReference(final CtPackageReference reference) {
		enter(reference);
		scan(reference.getAnnotations());
		exit(reference);
	}

	public <T> void visitCtParameter(final CtParameter<T> parameter) {
		enter(parameter);
		scan(parameter.getAnnotations());
		scan(parameter.getType());
		scan(parameter.getComments());
		exit(parameter);
	}

	public <T> void visitCtParameterReference(final CtParameterReference<T> reference) {
		enter(reference);
		scan(reference.getType());
		scan(reference.getAnnotations());
		scan(reference.getDeclaringExecutable());
		exit(reference);
	}

	public <R> void visitCtReturn(final CtReturn<R> returnStatement) {
		enter(returnStatement);
		scan(returnStatement.getAnnotations());
		scan(returnStatement.getReturnedExpression());
		scan(returnStatement.getComments());
		exit(returnStatement);
	}

	public <R> void visitCtStatementList(final CtStatementList statements) {
		enter(statements);
		scan(statements.getAnnotations());
		scan(statements.getStatements());
		scan(statements.getComments());
		exit(statements);
	}

	public <S> void visitCtSwitch(final CtSwitch<S> switchStatement) {
		enter(switchStatement);
		scan(switchStatement.getAnnotations());
		scan(switchStatement.getSelector());
		scan(switchStatement.getCases());
		scan(switchStatement.getComments());
		exit(switchStatement);
	}

	public void visitCtSynchronized(final CtSynchronized synchro) {
		enter(synchro);
		scan(synchro.getAnnotations());
		scan(synchro.getExpression());
		scan(synchro.getBlock());
		scan(synchro.getComments());
		exit(synchro);
	}

	public void visitCtThrow(final CtThrow throwStatement) {
		enter(throwStatement);
		scan(throwStatement.getAnnotations());
		scan(throwStatement.getThrownExpression());
		scan(throwStatement.getComments());
		exit(throwStatement);
	}

	public void visitCtTry(final CtTry tryBlock) {
		enter(tryBlock);
		scan(tryBlock.getAnnotations());
		scan(tryBlock.getBody());
		scan(tryBlock.getCatchers());
		scan(tryBlock.getFinalizer());
		scan(tryBlock.getComments());
		exit(tryBlock);
	}

	@Override
	public void visitCtTryWithResource(final CtTryWithResource tryWithResource) {
		enter(tryWithResource);
		scan(tryWithResource.getAnnotations());
		scan(tryWithResource.getResources());
		scan(tryWithResource.getBody());
		scan(tryWithResource.getCatchers());
		scan(tryWithResource.getFinalizer());
		scan(tryWithResource.getComments());
		exit(tryWithResource);
	}

	public void visitCtTypeParameterReference(final CtTypeParameterReference ref) {
		enter(ref);
		scan(ref.getPackage());
		scan(ref.getDeclaringType());
		scan(ref.getAnnotations());
		scan(ref.getBoundingType());
		exit(ref);
	}

	@Override
	public void visitCtWildcardReference(CtWildcardReference wildcardReference) {
		enter(wildcardReference);
		scan(wildcardReference.getPackage());
		scan(wildcardReference.getDeclaringType());
		scan(wildcardReference.getAnnotations());
		scan(wildcardReference.getBoundingType());
		exit(wildcardReference);
	}

	@Override
	public <T> void visitCtIntersectionTypeReference(final CtIntersectionTypeReference<T> reference) {
		enter(reference);
		scan(reference.getPackage());
		scan(reference.getDeclaringType());
		scan(reference.getAnnotations());
		scan(reference.getBounds());
		exit(reference);
	}

	public <T> void visitCtTypeReference(final CtTypeReference<T> reference) {
		enter(reference);
		scan(reference.getPackage());
		scan(reference.getDeclaringType());
		scan(reference.getActualTypeArguments());
		scan(reference.getAnnotations());
		scan(reference.getComments());
		exit(reference);
	}

	@Override
	public <T> void visitCtTypeAccess(final CtTypeAccess<T> typeAccess) {
		enter(typeAccess);
		scan(typeAccess.getAnnotations());
		scan(typeAccess.getTypeCasts());
		scan(typeAccess.getAccessedType());
		scan(typeAccess.getComments());
		exit(typeAccess);
	}

	public <T> void visitCtUnaryOperator(final CtUnaryOperator<T> operator) {
		enter(operator);
		scan(operator.getAnnotations());
		scan(operator.getType());
		scan(operator.getTypeCasts());
		scan(operator.getOperand());
		scan(operator.getComments());
		exit(operator);
	}

	@Override
	public <T> void visitCtVariableRead(final CtVariableRead<T> variableRead) {
		enter(variableRead);
		scan(variableRead.getAnnotations());
		scan(variableRead.getTypeCasts());
		scan(variableRead.getVariable());
		scan(variableRead.getComments());
		exit(variableRead);
	}

	@Override
	public <T> void visitCtVariableWrite(final CtVariableWrite<T> variableWrite) {
		enter(variableWrite);
		scan(variableWrite.getAnnotations());
		scan(variableWrite.getTypeCasts());
		scan(variableWrite.getVariable());
		scan(variableWrite.getComments());
		exit(variableWrite);
	}

	public void visitCtWhile(final CtWhile whileLoop) {
		enter(whileLoop);
		scan(whileLoop.getAnnotations());
		scan(whileLoop.getLoopingExpression());
		scan(whileLoop.getBody());
		scan(whileLoop.getComments());
		exit(whileLoop);
	}

	public <T> void visitCtCodeSnippetExpression(final CtCodeSnippetExpression<T> expression) {
		System.out.println("CtScanner.visitCtCodeSnippetExpression()" + expression);
		enter(expression);
		scan(expression.getType());
		scan(expression.getComments());
		scan(expression.getAnnotations());
		scan(expression.getTypeCasts());
		exit(expression);
	}

	public void visitCtCodeSnippetStatement(final CtCodeSnippetStatement statement) {
		System.out.println("CtScanner.visitCtCodeSnippetStatement()" + statement);
		enter(statement);
		scan(statement.getComments());
		scan(statement.getAnnotations());
		exit(statement);
	}

	public <T> void visitCtUnboundVariableReference(final CtUnboundVariableReference<T> reference) {
		enter(reference);
		scan(reference.getType());
		exit(reference);
	}

	@Override
	public <T> void visitCtFieldRead(final CtFieldRead<T> fieldRead) {
		enter(fieldRead);
		scan(fieldRead.getAnnotations());
		scan(fieldRead.getTypeCasts());
		scan(fieldRead.getTarget());
		scan(fieldRead.getVariable());
		scan(fieldRead.getComments());
		exit(fieldRead);
	}

	@Override
	public <T> void visitCtFieldWrite(final CtFieldWrite<T> fieldWrite) {
		enter(fieldWrite);
		scan(fieldWrite.getAnnotations());
		scan(fieldWrite.getTypeCasts());
		scan(fieldWrite.getTarget());
		scan(fieldWrite.getVariable());
		scan(fieldWrite.getComments());
		exit(fieldWrite);
	}

	@Override
	public <T> void visitCtSuperAccess(final CtSuperAccess<T> f) {
		enter(f);
		scan(f.getType());
		scan(f.getComments());
		scan(f.getAnnotations());
		scan(f.getTypeCasts());
		scan(f.getTarget());
		scan(f.getVariable());
		exit(f);
	}

	@Override
	public void visitCtComment(final CtComment comment) {
		enter(comment);
		scan(comment.getComments());
		scan(comment.getAnnotations());
		exit(comment);
	}
}