diff --git a/src/main/java/spoon/reflect/factory/Factory.java b/src/main/java/spoon/reflect/factory/Factory.java
index 65d5201893b..06305f93ecd 100644
--- a/src/main/java/spoon/reflect/factory/Factory.java
+++ b/src/main/java/spoon/reflect/factory/Factory.java
@@ -18,6 +18,95 @@
 
 import spoon.compiler.Environment;
 import spoon.reflect.CtModel;
+import spoon.reflect.code.BinaryOperatorKind;
+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.CtFieldAccess;
+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.CtVariableAccess;
+import spoon.reflect.code.CtVariableRead;
+import spoon.reflect.code.CtVariableWrite;
+import spoon.reflect.code.CtWhile;
+import spoon.reflect.cu.CompilationUnit;
+import spoon.reflect.cu.SourcePosition;
+import spoon.reflect.cu.position.BodyHolderSourcePosition;
+import spoon.reflect.cu.position.DeclarationSourcePosition;
+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.CtEnum;
+import spoon.reflect.declaration.CtEnumValue;
+import spoon.reflect.declaration.CtExecutable;
+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.CtType;
+import spoon.reflect.declaration.CtTypeParameter;
+import spoon.reflect.declaration.CtVariable;
+import spoon.reflect.declaration.ModifierKind;
+import spoon.reflect.eval.PartialEvaluator;
+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.CtVariableReference;
+import spoon.reflect.reference.CtWildcardReference;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
 
 /**
  * Provides the sub-factories required by Spoon.
@@ -60,4 +149,617 @@ public interface Factory {
 	EvalFactory Eval(); // used 4 times
 
 	ConstructorFactory Constructor(); // used 3 times
+
+	/**
+	 *  @see CodeFactory#createAnnotation(CtTypeReference)
+	 */
+	<A extends Annotation> CtAnnotation<A> createAnnotation(CtTypeReference<A> annotationType);
+
+	/**
+	 *  @see CodeFactory#createVariableAssignment(CtVariableReference,boolean, CtExpression)
+	 */
+	<A, T extends A> CtAssignment<A, T> createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression);
+
+	/**
+	 *  @see CodeFactory#createStatementList(CtBlock)
+	 */
+	<R> CtStatementList createStatementList(CtBlock<R> block);
+
+	/**
+	 *  @see CodeFactory#createCtBlock(T)
+	 */
+	<T extends CtStatement> CtBlock<?> createCtBlock(T element);
+
+	/**
+	 *  @see CodeFactory#createBinaryOperator(CtExpression,CtExpression, BinaryOperatorKind)
+	 */
+	<T> CtBinaryOperator<T> createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind);
+
+	/**
+	 *  @see CodeFactory#createCatchVariable(CtTypeReference,String, ModifierKind[])
+	 */
+	<T> CtCatchVariable<T> createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds);
+
+	/**
+	 *  @see CodeFactory#createCodeSnippetExpression(String)
+	 */
+	<T> CtCodeSnippetExpression<T> createCodeSnippetExpression(String expression);
+
+	/**
+	 *  @see CodeFactory#createConstructorCall(CtTypeReference,CtExpression[])
+	 */
+	<T> CtConstructorCall<T> createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters);
+
+	/**
+	 *  @see CodeFactory#createClassAccess(CtTypeReference)
+	 */
+	<T> CtFieldAccess<Class<T>> createClassAccess(CtTypeReference<T> type);
+
+	/**
+	 *  @see CodeFactory#createInvocation(CtExpression, CtExecutableReference, List)
+	 */
+	<T> CtInvocation<T> createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments);
+
+	/**
+	 *  @see CodeFactory#createInvocation(CtExpression,CtExecutableReference,CtExpression[])
+	 */
+	<T> CtInvocation<T> createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments);
+
+	/**
+	 *  @see CodeFactory#createLiteral(T)
+	 */
+	<T> CtLiteral<T> createLiteral(T value);
+
+	/**
+	 *  @see CodeFactory#createLocalVariable(CtTypeReference,String,CtExpression)
+	 */
+	<T> CtLocalVariable<T> createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression);
+
+	/**
+	 *  @see CodeFactory#createLiteralArray(T[])
+	 */
+	@SuppressWarnings(value = "unchecked")
+	<T> CtNewArray<T[]> createLiteralArray(T[] value);
+
+	/**
+	 *  @see CodeFactory#createNewClass(CtTypeReference, CtClass,CtExpression[])
+	 */
+	<T> CtNewClass<T> createNewClass(CtTypeReference<T> type, CtClass<?> anonymousClass, CtExpression<?>... parameters);
+
+	/**
+	 *  @see CodeFactory#createVariableAssignments(List,List)
+	 */
+	<T> CtStatementList createVariableAssignments(List<? extends CtVariable<T>> variables, List<? extends CtExpression<T>> expressions);
+
+	/**
+	 *  @see CodeFactory#createThisAccess(CtTypeReference)
+	 */
+	<T> CtThisAccess<T> createThisAccess(CtTypeReference<T> type);
+
+	/**
+	 *  @see CodeFactory#createThisAccess(CtTypeReference,boolean)
+	 */
+	<T> CtThisAccess<T> createThisAccess(CtTypeReference<T> type, boolean isImplicit);
+
+	/**
+	 *  @see CodeFactory#createTypeAccess(CtTypeReference)
+	 */
+	<T> CtTypeAccess<T> createTypeAccess(CtTypeReference<T> accessedType);
+
+	/**
+	 *  @see CodeFactory#createTypeAccess(CtTypeReference,boolean)
+	 */
+	<T> CtTypeAccess<T> createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit);
+
+	/**
+	 *  @see CodeFactory#createTypeAccessWithoutCloningReference(CtTypeReference)
+	 */
+	<T> CtTypeAccess<T> createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType);
+
+	/**
+	 *  @see CodeFactory#createVariableRead(CtVariableReference,boolean)
+	 */
+	<T> CtVariableAccess<T> createVariableRead(CtVariableReference<T> variable, boolean isStatic);
+
+	/**
+	 *  @see CodeFactory#createCtField(String,CtTypeReference,String,ModifierKind[])
+	 */
+	<T> CtField<T> createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities);
+
+	/**
+	 *  @see CodeFactory#createCatchVariableReference(CtCatchVariable)
+	 */
+	<T> CtCatchVariableReference<T> createCatchVariableReference(CtCatchVariable<T> catchVariable);
+
+	/**
+	 *  @see CodeFactory#createLocalVariableReference(CtLocalVariable)
+	 */
+	<T> CtLocalVariableReference<T> createLocalVariableReference(CtLocalVariable<T> localVariable);
+
+	/**
+	 *  @see CodeFactory#createLocalVariableReference(CtTypeReference,String)
+	 */
+	<T> CtLocalVariableReference<T> createLocalVariableReference(CtTypeReference<T> type, String name);
+
+	/**
+	 *  @see CodeFactory#createCtTypeReference(Class)
+	 */
+	<T> CtTypeReference<T> createCtTypeReference(Class<?> originalClass);
+
+	/**
+	 *  @see CodeFactory#createVariableReads(List)
+	 */
+	List<CtExpression<?>> createVariableReads(List<? extends CtVariable<?>> variables);
+
+	/**
+	 *  @see CodeFactory#createCtCatch(String,Class,CtBlock)
+	 */
+	CtCatch createCtCatch(String nameCatch, Class<? extends Throwable> exception, CtBlock<?> ctBlock);
+
+	/**
+	 *  @see CodeFactory#createCodeSnippetStatement(String)
+	 */
+	CtCodeSnippetStatement createCodeSnippetStatement(String statement);
+
+	/**
+	 *  @see CodeFactory#createComment(String,CtComment.CommentType)
+	 */
+	CtComment createComment(String content, CtComment.CommentType type);
+
+	/**
+	 *  @see CodeFactory#createInlineComment(String)
+	 */
+	CtComment createInlineComment(String content);
+
+	/**
+	 *  @see CodeFactory#createCtThrow(String)
+	 */
+	CtThrow createCtThrow(String thrownExp);
+
+	/**
+	 *  @see CodeFactory#createCtPackageReference(Package)
+	 */
+	CtPackageReference createCtPackageReference(Package originalPackage);
+
+	/**
+	 *  @see ConstructorFactory#createDefault(CtClass)
+	 */
+	<T> CtConstructor<T> createDefault(CtClass<T> target);
+
+	/**
+	 *  @see CoreFactory#createAnnotation()
+	 */
+	<A extends Annotation> CtAnnotation<A> createAnnotation();
+
+	/**
+	 *  @see CoreFactory#createBlock()
+	 */
+	<R> CtBlock<R> createBlock();
+
+	/**
+	 *  @see CoreFactory#createReturn()
+	 */
+	<R> CtReturn<R> createReturn();
+
+	/**
+	 *  @see CoreFactory#createStatementList()
+	 */
+	<R> CtStatementList createStatementList();
+
+	/**
+	 *  @see CoreFactory#createCase()
+	 */
+	<S> CtCase<S> createCase();
+
+	/**
+	 *  @see CoreFactory#createSwitch()
+	 */
+	<S> CtSwitch<S> createSwitch();
+
+	/**
+	 *  @see CoreFactory#createEnum()
+	 */
+	<T extends Enum<?>> CtEnum<T> createEnum();
+
+	/**
+	 *  @see CoreFactory#createAnnotationType()
+	 */
+	<T extends Annotation> CtAnnotationType<T> createAnnotationType();
+
+	/**
+	 *  @see CoreFactory#createAssignment()
+	 */
+	<T, A extends T> CtAssignment<T, A> createAssignment();
+
+	/**
+	 *  @see CoreFactory#createOperatorAssignment()
+	 */
+	<T, A extends T> CtOperatorAssignment<T, A> createOperatorAssignment();
+
+	/**
+	 *  @see CoreFactory#createExecutableReferenceExpression()
+	 */
+	<T, E extends CtExpression<?>> CtExecutableReferenceExpression<T, E> createExecutableReferenceExpression();
+
+	/**
+	 *  @see CoreFactory#createAnnotationFieldAccess()
+	 */
+	<T> CtAnnotationFieldAccess<T> createAnnotationFieldAccess();
+
+	/**
+	 *  @see CoreFactory#createArrayRead()
+	 */
+	<T> CtArrayRead<T> createArrayRead();
+
+	/**
+	 *  @see CoreFactory#createArrayWrite()
+	 */
+	<T> CtArrayWrite<T> createArrayWrite();
+
+	/**
+	 *  @see CoreFactory#createAssert()
+	 */
+	<T> CtAssert<T> createAssert();
+
+	/**
+	 *  @see CoreFactory#createBinaryOperator()
+	 */
+	<T> CtBinaryOperator<T> createBinaryOperator();
+
+	/**
+	 *  @see CoreFactory#createCatchVariable()
+	 */
+	<T> CtCatchVariable<T> createCatchVariable();
+
+	/**
+	 *  @see CoreFactory#createCodeSnippetExpression()
+	 */
+	<T> CtCodeSnippetExpression<T> createCodeSnippetExpression();
+
+	/**
+	 *  @see CoreFactory#createConditional()
+	 */
+	<T> CtConditional<T> createConditional();
+
+	/**
+	 *  @see CoreFactory#createConstructorCall()
+	 */
+	<T> CtConstructorCall<T> createConstructorCall();
+
+	/**
+	 *  @see CoreFactory#createFieldRead()
+	 */
+	<T> CtFieldRead<T> createFieldRead();
+
+	/**
+	 *  @see CoreFactory#createFieldWrite()
+	 */
+	<T> CtFieldWrite<T> createFieldWrite();
+
+	/**
+	 *  @see CoreFactory#createInvocation()
+	 */
+	<T> CtInvocation<T> createInvocation();
+
+	/**
+	 *  @see CoreFactory#createLambda()
+	 */
+	<T> CtLambda<T> createLambda();
+
+	/**
+	 *  @see CoreFactory#createLiteral()
+	 */
+	<T> CtLiteral<T> createLiteral();
+
+	/**
+	 *  @see CoreFactory#createLocalVariable()
+	 */
+	<T> CtLocalVariable<T> createLocalVariable();
+
+	/**
+	 *  @see CoreFactory#createNewArray()
+	 */
+	<T> CtNewArray<T> createNewArray();
+
+	/**
+	 *  @see CoreFactory#createNewClass()
+	 */
+	<T> CtNewClass<T> createNewClass();
+
+	/**
+	 *  @see CoreFactory#createSuperAccess()
+	 */
+	<T> CtSuperAccess<T> createSuperAccess();
+
+	/**
+	 *  @see CoreFactory#createThisAccess()
+	 */
+	<T> CtThisAccess<T> createThisAccess();
+
+	/**
+	 *  @see CoreFactory#createTypeAccess()
+	 */
+	<T> CtTypeAccess<T> createTypeAccess();
+
+	/**
+	 *  @see CoreFactory#createUnaryOperator()
+	 */
+	<T> CtUnaryOperator<T> createUnaryOperator();
+
+	/**
+	 *  @see CoreFactory#createVariableRead()
+	 */
+	<T> CtVariableRead<T> createVariableRead();
+
+	/**
+	 *  @see CoreFactory#createVariableWrite()
+	 */
+	<T> CtVariableWrite<T> createVariableWrite();
+
+	/**
+	 *  @see CoreFactory#createAnnotationMethod()
+	 */
+	<T> CtAnnotationMethod<T> createAnnotationMethod();
+
+	/**
+	 *  @see CoreFactory#createClass()
+	 */
+	<T> CtClass<T> createClass();
+
+	/**
+	 *  @see CoreFactory#createConstructor()
+	 */
+	<T> CtConstructor<T> createConstructor();
+
+	/**
+	 *  @see CoreFactory#createEnumValue()
+	 */
+	<T> CtEnumValue<T> createEnumValue();
+
+	/**
+	 *  @see CoreFactory#createField()
+	 */
+	<T> CtField<T> createField();
+
+	/**
+	 *  @see CoreFactory#createInterface()
+	 */
+	<T> CtInterface<T> createInterface();
+
+	/**
+	 *  @see CoreFactory#createMethod()
+	 */
+	<T> CtMethod<T> createMethod();
+
+	/**
+	 *  @see CoreFactory#createParameter()
+	 */
+	<T> CtParameter<T> createParameter();
+
+	/**
+	 *  @see CoreFactory#createArrayTypeReference()
+	 */
+	<T> CtArrayTypeReference<T> createArrayTypeReference();
+
+	/**
+	 *  @see CoreFactory#createCatchVariableReference()
+	 */
+	<T> CtCatchVariableReference<T> createCatchVariableReference();
+
+	/**
+	 *  @see CoreFactory#createExecutableReference()
+	 */
+	<T> CtExecutableReference<T> createExecutableReference();
+
+	/**
+	 *  @see CoreFactory#createFieldReference()
+	 */
+	<T> CtFieldReference<T> createFieldReference();
+
+	/**
+	 *  @see CoreFactory#createIntersectionTypeReference()
+	 */
+	<T> CtIntersectionTypeReference<T> createIntersectionTypeReference();
+
+	/**
+	 *  @see CoreFactory#createLocalVariableReference()
+	 */
+	<T> CtLocalVariableReference<T> createLocalVariableReference();
+
+	/**
+	 *  @see CoreFactory#createParameterReference()
+	 */
+	<T> CtParameterReference<T> createParameterReference();
+
+	/**
+	 *  @see CoreFactory#createTypeReference()
+	 */
+	<T> CtTypeReference<T> createTypeReference();
+
+	/**
+	 *  @see CoreFactory#createUnboundVariableReference()
+	 */
+	<T> CtUnboundVariableReference<T> createUnboundVariableReference();
+
+	/**
+	 *  @see CoreFactory#createBreak()
+	 */
+	CtBreak createBreak();
+
+	/**
+	 *  @see CoreFactory#createCatch()
+	 */
+	CtCatch createCatch();
+
+	/**
+	 *  @see CoreFactory#createCodeSnippetStatement()
+	 */
+	CtCodeSnippetStatement createCodeSnippetStatement();
+
+	/**
+	 *  @see CoreFactory#createComment()
+	 */
+	CtComment createComment();
+
+	/**
+	 *  @see CoreFactory#createContinue()
+	 */
+	CtContinue createContinue();
+
+	/**
+	 *  @see CoreFactory#createDo()
+	 */
+	CtDo createDo();
+
+	/**
+	 *  @see CoreFactory#createFor()
+	 */
+	CtFor createFor();
+
+	/**
+	 *  @see CoreFactory#createForEach()
+	 */
+	CtForEach createForEach();
+
+	/**
+	 *  @see CoreFactory#createIf()
+	 */
+	CtIf createIf();
+
+	/**
+	 *  @see CoreFactory#createSynchronized()
+	 */
+	CtSynchronized createSynchronized();
+
+	/**
+	 *  @see CoreFactory#createThrow()
+	 */
+	CtThrow createThrow();
+
+	/**
+	 *  @see CoreFactory#createTry()
+	 */
+	CtTry createTry();
+
+	/**
+	 *  @see CoreFactory#createTryWithResource()
+	 */
+	CtTryWithResource createTryWithResource();
+
+	/**
+	 *  @see CoreFactory#createWhile()
+	 */
+	CtWhile createWhile();
+
+	/**
+	 *  @see CoreFactory#createCompilationUnit()
+	 */
+	CompilationUnit createCompilationUnit();
+
+	/**
+	 *  @see CoreFactory#createSourcePosition(CompilationUnit,int,int,int,int[])
+	 */
+	@Deprecated
+	SourcePosition createSourcePosition(CompilationUnit compilationUnit, int startDeclaration, int startSource, int end, int[] lineSeparatorPositions);
+
+	/**
+	 *  @see CoreFactory#createSourcePosition(CompilationUnit,int,int,int[])
+	 */
+	SourcePosition createSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int[] lineSeparatorPositions);
+
+	/**
+	 *  @see CoreFactory#createBodyHolderSourcePosition(CompilationUnit,int,int,int,int,int,int,int,int,int[])
+	 */
+	BodyHolderSourcePosition createBodyHolderSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int bodyStart, int bodyEnd, int[] lineSeparatorPositions);
+
+	/**
+	 *  @see CoreFactory#createDeclarationSourcePosition(CompilationUnit,int,int,int,int,int,int,int[])
+	 */
+	DeclarationSourcePosition createDeclarationSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int[] lineSeparatorPositions);
+
+	/**
+	 *  @see CoreFactory#createAnonymousExecutable()
+	 */
+	CtAnonymousExecutable createAnonymousExecutable();
+
+	/**
+	 *  @see CoreFactory#createPackage()
+	 */
+	CtPackage createPackage();
+
+	/**
+	 *  @see CoreFactory#createTypeParameter()
+	 */
+	CtTypeParameter createTypeParameter();
+
+	/**
+	 *  @see CoreFactory#createPackageReference()
+	 */
+	CtPackageReference createPackageReference();
+
+	/**
+	 *  @see CoreFactory#createTypeParameterReference()
+	 */
+	CtTypeParameterReference createTypeParameterReference();
+
+	/**
+	 *  @see CoreFactory#createWildcardReference()
+	 */
+	CtWildcardReference createWildcardReference();
+
+	/**
+	 *  @see EvalFactory#createPartialEvaluator()
+	 */
+	PartialEvaluator createPartialEvaluator();
+
+	/**
+	 *  @see ExecutableFactory#createParameter(CtExecutable,CtTypeReference,String)
+	 */
+	<T> CtParameter<T> createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name);
+
+	/**
+	 *  @see ExecutableFactory#createParameterReference(CtParameter)
+	 */
+	<T> CtParameterReference<T> createParameterReference(CtParameter<T> parameter);
+
+	/**
+	 *  @see ExecutableFactory#createAnonymous(CtClass,CtBlock)
+	 */
+	CtAnonymousExecutable createAnonymous(CtClass<?> target, CtBlock<Void> body);
+
+	/**
+	 *  @see TypeFactory#createArrayReference(String)
+	 */
+	<T> CtArrayTypeReference<T> createArrayReference(String qualifiedName);
+
+	/**
+	 *  @see TypeFactory#createArrayReference(CtType)
+	 */
+	<T> CtArrayTypeReference<T[]> createArrayReference(CtType<T> type);
+
+	/**
+	 *  @see TypeFactory#createArrayReference(CtTypeReference)
+	 */
+	<T> CtArrayTypeReference<T[]> createArrayReference(CtTypeReference<T> reference);
+
+	/**
+	 *  @see TypeFactory#createIntersectionTypeReferenceWithBounds(List)
+	 */
+	<T> CtIntersectionTypeReference<T> createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds);
+
+	/**
+	 *  @see TypeFactory#createReferences(List)
+	 */
+	List<CtTypeReference<?>> createReferences(List<Class<?>> classes);
+
+	/**
+	 *  @see TypeFactory#createArrayReference(CtTypeReference,int)
+	 */
+	CtArrayTypeReference<?> createArrayReference(CtTypeReference<?> reference, int n);
+
+	/**
+	 *  @see TypeFactory#createTypeParameterReference(String)
+	 */
+	CtTypeParameterReference createTypeParameterReference(String name);
+
 }
diff --git a/src/main/java/spoon/reflect/factory/FactoryImpl.java b/src/main/java/spoon/reflect/factory/FactoryImpl.java
index bf24af4e0a4..6952ef4f7ab 100644
--- a/src/main/java/spoon/reflect/factory/FactoryImpl.java
+++ b/src/main/java/spoon/reflect/factory/FactoryImpl.java
@@ -19,23 +19,100 @@
 import spoon.compiler.Environment;
 import spoon.reflect.CtModel;
 import spoon.reflect.CtModelImpl;
+import spoon.reflect.code.BinaryOperatorKind;
+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.CtFieldAccess;
+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.CtVariableAccess;
+import spoon.reflect.code.CtVariableRead;
+import spoon.reflect.code.CtVariableWrite;
+import spoon.reflect.code.CtWhile;
 import spoon.reflect.cu.CompilationUnit;
+import spoon.reflect.cu.SourcePosition;
+import spoon.reflect.cu.position.BodyHolderSourcePosition;
+import spoon.reflect.cu.position.DeclarationSourcePosition;
+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.CtEnum;
+import spoon.reflect.declaration.CtEnumValue;
 import spoon.reflect.declaration.CtExecutable;
 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.CtType;
+import spoon.reflect.declaration.CtTypeParameter;
+import spoon.reflect.declaration.CtVariable;
+import spoon.reflect.declaration.ModifierKind;
+import spoon.reflect.eval.PartialEvaluator;
+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.CtVariableReference;
+import spoon.reflect.reference.CtWildcardReference;
 import spoon.support.DefaultCoreFactory;
 import spoon.support.StandardEnvironment;
 
 import java.io.IOException;
 import java.io.Serializable;
+import java.lang.annotation.Annotation;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
@@ -334,4 +411,617 @@ protected Dedup initialValue() {
 	public CtModel getModel() {
 		return model;
 	}
+
+	@Override
+	public <A extends Annotation> CtAnnotation<A> createAnnotation(CtTypeReference<A> annotationType) {
+		return Code().createAnnotation(annotationType);
+	}
+
+	@Override
+	public <A, T extends A> CtAssignment<A, T> createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression) {
+		return Code().createVariableAssignment(variable, isStatic, expression);
+	}
+
+	@Override
+	public <R> CtStatementList createStatementList(CtBlock<R> block) {
+		return Code().createStatementList(block);
+	}
+
+	@Override
+	public <T extends CtStatement> CtBlock<?> createCtBlock(T element) {
+		return Code().createCtBlock(element);
+	}
+
+	@Override
+	public <T> CtBinaryOperator<T> createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind) {
+		return Code().createBinaryOperator(left, right, kind);
+	}
+
+	@Override
+	public <T> CtCatchVariable<T> createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds) {
+		return Code().createCatchVariable(type, name, modifierKinds);
+	}
+
+	@Override
+	public <T> CtCodeSnippetExpression<T> createCodeSnippetExpression(String expression) {
+		return Code().createCodeSnippetExpression(expression);
+	}
+
+	@Override
+	public <T> CtConstructorCall<T> createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters) {
+		return Code().createConstructorCall(type, parameters);
+	}
+
+	@Override
+	public <T> CtFieldAccess<Class<T>> createClassAccess(CtTypeReference<T> type) {
+		return Code().createClassAccess(type);
+	}
+
+	@Override
+	public <T> CtInvocation<T> createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments) {
+		return Code().createInvocation(target, executable, arguments);
+	}
+
+	@Override
+	public <T> CtInvocation<T> createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments) {
+		return Code().createInvocation(target, executable, arguments);
+	}
+
+	@Override
+	public <T> CtLiteral<T> createLiteral(T value) {
+		return Code().createLiteral(value);
+	}
+
+	@Override
+	public <T> CtLocalVariable<T> createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression) {
+		return Code().createLocalVariable(type, name, defaultExpression);
+	}
+
+	@SuppressWarnings(value = "unchecked")
+	@Override
+	public <T> CtNewArray<T[]> createLiteralArray(T[] value) {
+		return Code().createLiteralArray(value);
+	}
+
+	@Override
+	public <T> CtNewClass<T> createNewClass(CtTypeReference<T> type, CtClass<?> anonymousClass, CtExpression<?>... parameters) {
+		return Code().createNewClass(type, anonymousClass, parameters);
+	}
+
+	@Override
+	public <T> CtStatementList createVariableAssignments(List<? extends CtVariable<T>> variables, List<? extends CtExpression<T>> expressions) {
+		return Code().createVariableAssignments(variables, expressions);
+	}
+
+	@Override
+	public <T> CtThisAccess<T> createThisAccess(CtTypeReference<T> type) {
+		return Code().createThisAccess(type);
+	}
+
+	@Override
+	public <T> CtThisAccess<T> createThisAccess(CtTypeReference<T> type, boolean isImplicit) {
+		return Code().createThisAccess(type, isImplicit);
+	}
+
+	@Override
+	public <T> CtTypeAccess<T> createTypeAccess(CtTypeReference<T> accessedType) {
+		return Code().createTypeAccess(accessedType);
+	}
+
+	@Override
+	public <T> CtTypeAccess<T> createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit) {
+		return Code().createTypeAccess(accessedType, isImplicit);
+	}
+
+	@Override
+	public <T> CtTypeAccess<T> createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType) {
+		return Code().createTypeAccessWithoutCloningReference(accessedType);
+	}
+
+	@Override
+	public <T> CtVariableAccess<T> createVariableRead(CtVariableReference<T> variable, boolean isStatic) {
+		return Code().createVariableRead(variable, isStatic);
+	}
+
+	@Override
+	public <T> CtField<T> createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities) {
+		return Code().createCtField(name, type, exp, visibilities);
+	}
+
+	@Override
+	public <T> CtCatchVariableReference<T> createCatchVariableReference(CtCatchVariable<T> catchVariable) {
+		return Code().createCatchVariableReference(catchVariable);
+	}
+
+	@Override
+	public <T> CtLocalVariableReference<T> createLocalVariableReference(CtLocalVariable<T> localVariable) {
+		return Code().createLocalVariableReference(localVariable);
+	}
+
+	@Override
+	public <T> CtLocalVariableReference<T> createLocalVariableReference(CtTypeReference<T> type, String name) {
+		return Code().createLocalVariableReference(type, name);
+	}
+
+	@Override
+	public <T> CtTypeReference<T> createCtTypeReference(Class<?> originalClass) {
+		return Code().createCtTypeReference(originalClass);
+	}
+
+	@Override
+	public List<CtExpression<?>> createVariableReads(List<? extends CtVariable<?>> variables) {
+		return Code().createVariableReads(variables);
+	}
+
+	@Override
+	public CtCatch createCtCatch(String nameCatch, Class<? extends Throwable> exception, CtBlock<?> ctBlock) {
+		return Code().createCtCatch(nameCatch, exception, ctBlock);
+	}
+
+	@Override
+	public CtCodeSnippetStatement createCodeSnippetStatement(String statement) {
+		return Code().createCodeSnippetStatement(statement);
+	}
+
+	@Override
+	public CtComment createComment(String content, CtComment.CommentType type) {
+		return Code().createComment(content, type);
+	}
+
+	@Override
+	public CtComment createInlineComment(String content) {
+		return Code().createInlineComment(content);
+	}
+
+	@Override
+	public CtThrow createCtThrow(String thrownExp) {
+		return Code().createCtThrow(thrownExp);
+	}
+
+	@Override
+	public CtPackageReference createCtPackageReference(Package originalPackage) {
+		return Code().createCtPackageReference(originalPackage);
+	}
+
+	@Override
+	public <T> CtConstructor<T> createDefault(CtClass<T> target) {
+		return Constructor().createDefault(target);
+	}
+
+	@Override
+	public <A extends Annotation> CtAnnotation<A> createAnnotation() {
+		return Core().createAnnotation();
+	}
+
+	@Override
+	public <R> CtBlock<R> createBlock() {
+		return Core().createBlock();
+	}
+
+	@Override
+	public <R> CtReturn<R> createReturn() {
+		return Core().createReturn();
+	}
+
+	@Override
+	public <R> CtStatementList createStatementList() {
+		return Core().createStatementList();
+	}
+
+	@Override
+	public <S> CtCase<S> createCase() {
+		return Core().createCase();
+	}
+
+	@Override
+	public <S> CtSwitch<S> createSwitch() {
+		return Core().createSwitch();
+	}
+
+	@Override
+	public <T extends Enum<?>> CtEnum<T> createEnum() {
+		return Core().createEnum();
+	}
+
+	@Override
+	public <T extends Annotation> CtAnnotationType<T> createAnnotationType() {
+		return Core().createAnnotationType();
+	}
+
+	@Override
+	public <T, A extends T> CtAssignment<T, A> createAssignment() {
+		return Core().createAssignment();
+	}
+
+	@Override
+	public <T, A extends T> CtOperatorAssignment<T, A> createOperatorAssignment() {
+		return Core().createOperatorAssignment();
+	}
+
+	@Override
+	public <T, E extends CtExpression<?>> CtExecutableReferenceExpression<T, E> createExecutableReferenceExpression() {
+		return Core().createExecutableReferenceExpression();
+	}
+
+	@Override
+	public <T> CtAnnotationFieldAccess<T> createAnnotationFieldAccess() {
+		return Core().createAnnotationFieldAccess();
+	}
+
+	@Override
+	public <T> CtArrayRead<T> createArrayRead() {
+		return Core().createArrayRead();
+	}
+
+	@Override
+	public <T> CtArrayWrite<T> createArrayWrite() {
+		return Core().createArrayWrite();
+	}
+
+	@Override
+	public <T> CtAssert<T> createAssert() {
+		return Core().createAssert();
+	}
+
+	@Override
+	public <T> CtBinaryOperator<T> createBinaryOperator() {
+		return Core().createBinaryOperator();
+	}
+
+	@Override
+	public <T> CtCatchVariable<T> createCatchVariable() {
+		return Core().createCatchVariable();
+	}
+
+	@Override
+	public <T> CtCodeSnippetExpression<T> createCodeSnippetExpression() {
+		return Core().createCodeSnippetExpression();
+	}
+
+	@Override
+	public <T> CtConditional<T> createConditional() {
+		return Core().createConditional();
+	}
+
+	@Override
+	public <T> CtConstructorCall<T> createConstructorCall() {
+		return Core().createConstructorCall();
+	}
+
+	@Override
+	public <T> CtFieldRead<T> createFieldRead() {
+		return Core().createFieldRead();
+	}
+
+	@Override
+	public <T> CtFieldWrite<T> createFieldWrite() {
+		return Core().createFieldWrite();
+	}
+
+	@Override
+	public <T> CtInvocation<T> createInvocation() {
+		return Core().createInvocation();
+	}
+
+	@Override
+	public <T> CtLambda<T> createLambda() {
+		return Core().createLambda();
+	}
+
+	@Override
+	public <T> CtLiteral<T> createLiteral() {
+		return Core().createLiteral();
+	}
+
+	@Override
+	public <T> CtLocalVariable<T> createLocalVariable() {
+		return Core().createLocalVariable();
+	}
+
+	@Override
+	public <T> CtNewArray<T> createNewArray() {
+		return Core().createNewArray();
+	}
+
+	@Override
+	public <T> CtNewClass<T> createNewClass() {
+		return Core().createNewClass();
+	}
+
+	@Override
+	public <T> CtSuperAccess<T> createSuperAccess() {
+		return Core().createSuperAccess();
+	}
+
+	@Override
+	public <T> CtThisAccess<T> createThisAccess() {
+		return Core().createThisAccess();
+	}
+
+	@Override
+	public <T> CtTypeAccess<T> createTypeAccess() {
+		return Core().createTypeAccess();
+	}
+
+	@Override
+	public <T> CtUnaryOperator<T> createUnaryOperator() {
+		return Core().createUnaryOperator();
+	}
+
+	@Override
+	public <T> CtVariableRead<T> createVariableRead() {
+		return Core().createVariableRead();
+	}
+
+	@Override
+	public <T> CtVariableWrite<T> createVariableWrite() {
+		return Core().createVariableWrite();
+	}
+
+	@Override
+	public <T> CtAnnotationMethod<T> createAnnotationMethod() {
+		return Core().createAnnotationMethod();
+	}
+
+	@Override
+	public <T> CtClass<T> createClass() {
+		return Core().createClass();
+	}
+
+	@Override
+	public <T> CtConstructor<T> createConstructor() {
+		return Core().createConstructor();
+	}
+
+	@Override
+	public <T> CtEnumValue<T> createEnumValue() {
+		return Core().createEnumValue();
+	}
+
+	@Override
+	public <T> CtField<T> createField() {
+		return Core().createField();
+	}
+
+	@Override
+	public <T> CtInterface<T> createInterface() {
+		return Core().createInterface();
+	}
+
+	@Override
+	public <T> CtMethod<T> createMethod() {
+		return Core().createMethod();
+	}
+
+	@Override
+	public <T> CtParameter<T> createParameter() {
+		return Core().createParameter();
+	}
+
+	@Override
+	public <T> CtArrayTypeReference<T> createArrayTypeReference() {
+		return Core().createArrayTypeReference();
+	}
+
+	@Override
+	public <T> CtCatchVariableReference<T> createCatchVariableReference() {
+		return Core().createCatchVariableReference();
+	}
+
+	@Override
+	public <T> CtExecutableReference<T> createExecutableReference() {
+		return Core().createExecutableReference();
+	}
+
+	@Override
+	public <T> CtFieldReference<T> createFieldReference() {
+		return Core().createFieldReference();
+	}
+
+	@Override
+	public <T> CtIntersectionTypeReference<T> createIntersectionTypeReference() {
+		return Core().createIntersectionTypeReference();
+	}
+
+	@Override
+	public <T> CtLocalVariableReference<T> createLocalVariableReference() {
+		return Core().createLocalVariableReference();
+	}
+
+	@Override
+	public <T> CtParameterReference<T> createParameterReference() {
+		return Core().createParameterReference();
+	}
+
+	@Override
+	public <T> CtTypeReference<T> createTypeReference() {
+		return Core().createTypeReference();
+	}
+
+	@Override
+	public <T> CtUnboundVariableReference<T> createUnboundVariableReference() {
+		return Core().createUnboundVariableReference();
+	}
+
+	@Override
+	public CtBreak createBreak() {
+		return Core().createBreak();
+	}
+
+	@Override
+	public CtCatch createCatch() {
+		return Core().createCatch();
+	}
+
+	@Override
+	public CtCodeSnippetStatement createCodeSnippetStatement() {
+		return Core().createCodeSnippetStatement();
+	}
+
+	@Override
+	public CtComment createComment() {
+		return Core().createComment();
+	}
+
+	@Override
+	public CtContinue createContinue() {
+		return Core().createContinue();
+	}
+
+	@Override
+	public CtDo createDo() {
+		return Core().createDo();
+	}
+
+	@Override
+	public CtFor createFor() {
+		return Core().createFor();
+	}
+
+	@Override
+	public CtForEach createForEach() {
+		return Core().createForEach();
+	}
+
+	@Override
+	public CtIf createIf() {
+		return Core().createIf();
+	}
+
+	@Override
+	public CtSynchronized createSynchronized() {
+		return Core().createSynchronized();
+	}
+
+	@Override
+	public CtThrow createThrow() {
+		return Core().createThrow();
+	}
+
+	@Override
+	public CtTry createTry() {
+		return Core().createTry();
+	}
+
+	@Override
+	public CtTryWithResource createTryWithResource() {
+		return Core().createTryWithResource();
+	}
+
+	@Override
+	public CtWhile createWhile() {
+		return Core().createWhile();
+	}
+
+	@Override
+	public CompilationUnit createCompilationUnit() {
+		return Core().createCompilationUnit();
+	}
+
+	@Deprecated
+	@Override
+	public SourcePosition createSourcePosition(CompilationUnit compilationUnit, int startDeclaration, int startSource, int end, int[] lineSeparatorPositions) {
+		return Core().createSourcePosition(compilationUnit, startDeclaration, startSource, end, lineSeparatorPositions);
+	}
+
+	@Override
+	public SourcePosition createSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int[] lineSeparatorPositions) {
+		return Core().createSourcePosition(compilationUnit, startSource, end, lineSeparatorPositions);
+	}
+
+	@Override
+	public BodyHolderSourcePosition createBodyHolderSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int bodyStart, int bodyEnd, int[] lineSeparatorPositions) {
+		return Core().createBodyHolderSourcePosition(compilationUnit, startSource, end, modifierStart, modifierEnd, declarationStart, declarationEnd, bodyStart, bodyEnd, lineSeparatorPositions);
+	}
+
+	@Override
+	public DeclarationSourcePosition createDeclarationSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int[] lineSeparatorPositions) {
+		return Core().createDeclarationSourcePosition(compilationUnit, startSource, end, modifierStart, modifierEnd, declarationStart, declarationEnd, lineSeparatorPositions);
+	}
+
+	@Override
+	public CtAnonymousExecutable createAnonymousExecutable() {
+		return Core().createAnonymousExecutable();
+	}
+
+	@Override
+	public CtPackage createPackage() {
+		return Core().createPackage();
+	}
+
+	@Override
+	public CtTypeParameter createTypeParameter() {
+		return Core().createTypeParameter();
+	}
+
+	@Override
+	public CtPackageReference createPackageReference() {
+		return Core().createPackageReference();
+	}
+
+	@Override
+	public CtTypeParameterReference createTypeParameterReference() {
+		return Core().createTypeParameterReference();
+	}
+
+	@Override
+	public CtWildcardReference createWildcardReference() {
+		return Core().createWildcardReference();
+	}
+
+	@Override
+	public PartialEvaluator createPartialEvaluator() {
+		return Eval().createPartialEvaluator();
+	}
+
+	@Override
+	public <T> CtParameter<T> createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name) {
+		return Executable().createParameter(parent, type, name);
+	}
+
+	@Override
+	public <T> CtParameterReference<T> createParameterReference(CtParameter<T> parameter) {
+		return Executable().createParameterReference(parameter);
+	}
+
+	@Override
+	public CtAnonymousExecutable createAnonymous(CtClass<?> target, CtBlock<Void> body) {
+		return Executable().createAnonymous(target, body);
+	}
+
+	@Override
+	public <T> CtArrayTypeReference<T> createArrayReference(String qualifiedName) {
+		return Type().createArrayReference(qualifiedName);
+	}
+
+	@Override
+	public <T> CtArrayTypeReference<T[]> createArrayReference(CtType<T> type) {
+		return Type().createArrayReference(type);
+	}
+
+	@Override
+	public <T> CtArrayTypeReference<T[]> createArrayReference(CtTypeReference<T> reference) {
+		return Type().createArrayReference(reference);
+	}
+
+	@Override
+	public <T> CtIntersectionTypeReference<T> createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds) {
+		return Type().createIntersectionTypeReferenceWithBounds(bounds);
+	}
+
+	@Override
+	public List<CtTypeReference<?>> createReferences(List<Class<?>> classes) {
+		return Type().createReferences(classes);
+	}
+
+	@Override
+	public CtArrayTypeReference<?> createArrayReference(CtTypeReference<?> reference, int n) {
+		return Type().createArrayReference(reference, n);
+	}
+
+	@Override
+	public CtTypeParameterReference createTypeParameterReference(String name) {
+		return Type().createTypeParameterReference(name);
+	}
+
 }
diff --git a/src/test/java/spoon/test/architecture/SpoonArchitectureEnforcerTest.java b/src/test/java/spoon/test/architecture/SpoonArchitectureEnforcerTest.java
index 2ab43a2658f..991ca52e324 100644
--- a/src/test/java/spoon/test/architecture/SpoonArchitectureEnforcerTest.java
+++ b/src/test/java/spoon/test/architecture/SpoonArchitectureEnforcerTest.java
@@ -3,13 +3,18 @@
 import org.junit.Test;
 import spoon.Launcher;
 import spoon.SpoonAPI;
+import spoon.processing.AbstractManualProcessor;
 import spoon.reflect.code.CtConstructorCall;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtField;
+import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.ModifierKind;
+import spoon.reflect.factory.Factory;
+import spoon.reflect.factory.FactoryImpl;
 import spoon.reflect.visitor.filter.AbstractFilter;
 import spoon.reflect.visitor.filter.TypeFilter;
 
@@ -47,6 +52,48 @@ public boolean matches(CtType element) {
 
 	}
 
+	@Test
+	public void testFactorySubFactory() throws Exception {
+		// contract:: all subfactory methods must also be in the main factory
+		// this is very important for usability and discoverability
+		final Launcher launcher = new Launcher();
+		launcher.addInputResource("./src/main/java/spoon/reflect/factory");
+		class SanityCheck { int val = 0; };
+		SanityCheck sanityCheck = new SanityCheck();
+		launcher.addProcessor(new AbstractManualProcessor() {
+			@Override
+			public void process() {
+				CtType factoryImpl = getFactory().Interface().get(Factory.class);
+				CtPackage factoryPackage = getFactory().Package().getOrCreate("spoon.reflect.factory");
+				CtInterface itf = getFactory().Interface().create("MegaFactoryItf");
+				CtClass impl = getFactory().Class().create("MegaFactory");
+				for (CtType<?> t : factoryPackage.getTypes()) {
+					if (t.getSimpleName().startsWith("Mega")) continue; //
+					for (CtMethod<?> m : t.getMethods()) {
+						// we only consider factory methods
+						if (!m.getSimpleName().startsWith("create")) continue;
+
+						// too generic, what should we create??
+						if (m.getSimpleName().equals("create")) continue;
+
+						// too generic, is it a fieldref? an execref? etc
+						if (m.getSimpleName().equals("createReference"))
+							continue;
+
+						if (m.getModifiers().contains(ModifierKind.ABSTRACT)) continue;
+
+						sanityCheck.val++;
+
+						// the core assertion
+						assertTrue(factoryImpl.hasMethod(m));
+					}
+				}
+			}
+		});
+		launcher.run();
+		assertTrue(sanityCheck.val > 100);
+	}
+
 	@Test
 	public void noTreeSetInSpoon() throws Exception {
 		// we don't use TreeSet, because they implicitly depend on Comparable (no static check, only dynamic checks)