diff --git a/src/main/java/spoon/support/template/Parameters.java b/src/main/java/spoon/support/template/Parameters.java
index 06da96599ae..ed93b9ef6c5 100644
--- a/src/main/java/spoon/support/template/Parameters.java
+++ b/src/main/java/spoon/support/template/Parameters.java
@@ -22,6 +22,7 @@
 import spoon.reflect.code.CtLiteral;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtField;
+import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.CtTypeMember;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.reference.CtFieldReference;
@@ -36,6 +37,7 @@
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -69,9 +71,8 @@ public static Integer getIndex(CtExpression<?> e) {
 	 * Gets a template field parameter value.
 	 */
 	public static Object getValue(Template<?> template, String parameterName, Integer index) {
-		Object tparamValue = null;
+		Field rtField = null;
 		try {
-			Field rtField = null;
 			for (Field f : RtHelper.getAllFields(template.getClass())) {
 				if (isParameterSource(f)) {
 					if (parameterName.equals(getParameterName(f))) {
@@ -80,6 +81,20 @@ public static Object getValue(Template<?> template, String parameterName, Intege
 					}
 				}
 			}
+		} catch (Exception e) {
+			throw new UndefinedParameterException(e);
+		}
+		Object tparamValue = getValue(template, parameterName, rtField);
+		if (rtField.getType().isArray() && (index != null)) {
+			tparamValue = ((Object[]) tparamValue)[index];
+		}
+		return tparamValue;
+	}
+	private static Object getValue(Template<?> template, String parameterName, Field rtField) {
+		if (rtField == null) {
+			throw new UndefinedParameterException();
+		}
+		try {
 			if (Modifier.isFinal(rtField.getModifiers())) {
 				Map<String, Object> m = finals.get(template);
 				if (m == null) {
@@ -88,14 +103,10 @@ public static Object getValue(Template<?> template, String parameterName, Intege
 				return m.get(parameterName);
 			}
 			rtField.setAccessible(true);
-			tparamValue = rtField.get(template);
-			if (rtField.getType().isArray() && (index != null)) {
-				tparamValue = ((Object[]) tparamValue)[index];
-			}
+			return rtField.get(template);
 		} catch (Exception e) {
-			throw new UndefinedParameterException();
+			throw new UndefinedParameterException(e);
 		}
-		return tparamValue;
 	}
 
 	static Map<Template<?>, Map<String, Object>> finals = new HashMap<>();
@@ -194,6 +205,47 @@ public static List<String> getNames(CtClass<? extends Template<?>> templateType)
 		}
 		return params;
 	}
+	/**
+	 * Gets the Map of names to template parameter value for all the template parameters of a given template type
+	 * (including the ones defined by the super types).
+	 */
+	public static Map<String, Object> getNamesToValues(Template<?> template, CtClass<? extends Template<?>> templateType) {
+		//use linked hash map to assure same order of parameter names. There are cases during substitution of parameters when substitution order matters. E.g. SubstitutionVisitor#substituteName(...)
+		Map<String, Object> params = new LinkedHashMap<>();
+		try {
+			for (CtFieldReference<?> f : templateType.getAllFields()) {
+				if (isParameterSource(f)) {
+					String parameterName = getParameterName(f);
+					params.put(parameterName, getValue(template, parameterName, (Field) f.getActualField()));
+				}
+			}
+		} catch (Exception e) {
+			throw new SpoonException("Getting of template parameters failed", e);
+		}
+		return params;
+	}
+
+	/**
+	 * Gets the Map of names to template parameter values for all the template parameters of a given template type
+	 * + adds mapping of template model reference to target type as parameter too
+	 * @param f
+	 * 		the factory
+	 * @param targetType
+	 * 		the target type of the substitution (can be null), which will be done with result parameters
+	 * @param template
+	 * 		the template that holds the parameter values
+	 */
+	public static Map<String, Object> getTemplateParametersAsMap(Factory f, CtType<?> targetType, Template<?> template) {
+		Map<String, Object> params = new HashMap<>(Parameters.getNamesToValues(template, (CtClass) f.Class().get(template.getClass())));
+		if (targetType != null) {
+			/*
+			 * there is required to replace all template model references by target type reference.
+			 * Handle that request as template parameter too
+			 */
+			params.put(template.getClass().getSimpleName(), targetType.getReference());
+		}
+		return params;
+	}
 
 	/**
 	 * Tells if a given field is a template parameter.
diff --git a/src/main/java/spoon/support/template/SubstitutionVisitor.java b/src/main/java/spoon/support/template/SubstitutionVisitor.java
index 60f0da47dcc..5176121e247 100644
--- a/src/main/java/spoon/support/template/SubstitutionVisitor.java
+++ b/src/main/java/spoon/support/template/SubstitutionVisitor.java
@@ -19,6 +19,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 
 import spoon.SpoonException;
 import spoon.reflect.code.CtAbstractInvocation;
@@ -36,7 +37,6 @@
 import spoon.reflect.code.CtThisAccess;
 import spoon.reflect.code.CtVariableAccess;
 import spoon.reflect.declaration.CtAnnotation;
-import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtExecutable;
 import spoon.reflect.declaration.CtNamedElement;
@@ -54,6 +54,7 @@
 import spoon.reflect.visitor.Query;
 import spoon.reflect.visitor.filter.VariableAccessFilter;
 import spoon.template.Local;
+import spoon.template.Parameter;
 import spoon.template.Template;
 import spoon.template.TemplateParameter;
 
@@ -89,24 +90,23 @@ public InheritanceSustitutionScanner(SubstitutionVisitor parent) {
 		@Override
 		public <R> void scanCtExecutable(CtExecutable<R> e) {
 			// replace method parameters
-			for (CtParameter<?> parameter : new ArrayList<>(e.getParameters())) {
-				String name = parameter.getSimpleName();
-				for (String pname : parameterNames) {
-					if (name.equals(pname)) {
-						Object value = Parameters.getValue(template, pname, null);
-						int i = parameter.getParent().getParameters().indexOf(parameter);
-						if (value instanceof List) {
-							List<?> l = (List<?>) value;
-							for (Object p : l) {
-								CtParameter<?> p2 = ((CtParameter<?>) p).clone();
-								p2.setParent(parameter.getParent());
-								parameter.getParent().getParameters().add(i++, p2);
-							}
-							parameter.getParent().getParameters().remove(parameter);
-						}
-					}
+			List<CtParameter<?>> substitutedParams = new ArrayList<>(e.getParameters().size());
+			boolean wasChanged = false;
+			for (CtParameter<?> parameter : e.getParameters()) {
+				@SuppressWarnings({ "rawtypes", "unchecked" })
+				List<CtParameter<?>> list = (List) getParameterValueAsList(CtParameter.class, getParameterValue(parameter.getSimpleName()));
+				if (list == null) {
+					//it is normal parameter, keep it.
+					substitutedParams.add(parameter);
+				} else {
+					wasChanged = true;
+					//current parameter has to be substituted by a template parameter value
+					substitutedParams.addAll(list);
 				}
 			}
+			if (wasChanged) {
+				e.setParameters(substitutedParams);
+			}
 			super.scanCtExecutable(e);
 		}
 
@@ -129,66 +129,52 @@ public void scanCtElement(CtElement e) {
 		@Override
 		public void scanCtNamedElement(CtNamedElement element) {
 			if (element.getDocComment() != null) {
-				element.setDocComment(substituteInDocComment(element.getDocComment()));
+				element.setDocComment(substituteName(element.getDocComment()));
 			}
 			// replace parameters in names
-			element.setSimpleName(substituteName(element.getSimpleName(), element));
+			element.setSimpleName(substituteName(element.getSimpleName()));
 			super.scanCtNamedElement(element);
 		}
 
 		@Override
 		public void scanCtReference(CtReference reference) {
-			reference.setSimpleName(substituteName(reference.getSimpleName(), reference));
+			reference.setSimpleName(substituteName(reference.getSimpleName()));
 			super.scanCtReference(reference);
 		}
 
-		private String substituteName(String name, CtElement element) {
-			for (String pname : parameterNames) {
+		private String substituteName(String name) {
+			for (Map.Entry<String, Object> e : namesToValues.entrySet()) {
+				String pname = e.getKey();
 				if (name.contains(pname)) {
-					Object value = Parameters.getValue(template, pname, null);
-					if (value instanceof String) {
-						// replace with the string value
-						name = name.replace(pname, (String) value);
-					} else if ((value instanceof CtTypeReference) && (element instanceof CtType)) {
-						// replace with the type reference's name
-						name = name.replace(pname, ((CtTypeReference<?>) value).getSimpleName());
-					}
+					String value = getParameterValueAsString(e.getValue());
+					name = name.replace(pname, value);
 				}
 			}
 			return name;
 		}
 
-		private String substituteInDocComment(String docComment) {
-			String result = docComment;
-			for (String pname : parameterNames) {
-				Object value = Parameters.getValue(template, pname, null);
-				if (value instanceof String) {
-					result = result.replace(pname, (String) value);
-				}
-			}
-			return result;
-		}
-
 		/** statically inline foreach */
+		@SuppressWarnings({ "rawtypes", "unchecked" })
 		@Override
 		public void visitCtForEach(CtForEach foreach) {
 			if (foreach.getExpression() instanceof CtFieldAccess) {
 				CtFieldAccess<?> fa = (CtFieldAccess<?>) foreach.getExpression();
-				if (Parameters.isParameterSource(fa.getVariable())) {
-					Object[] value = (Object[]) Parameters.getValue(template, fa.getVariable().getSimpleName(), null);
+				Object value = getParameterValue(fa.getVariable().getSimpleName());
+				if (value != null) {
+					List<CtExpression> list = getParameterValueAsList(CtExpression.class, value);
 					CtBlock<?> l = foreach.getFactory().Core().createBlock();
 					CtStatement body = foreach.getBody();
-					for (Object element : value) {
+					for (CtExpression element : list) {
 						CtStatement b = body.clone();
 						for (CtVariableAccess<?> va : Query.getElements(b, new VariableAccessFilter<>(foreach.getVariable().getReference()))) {
-							va.replace((CtExpression) element);
+							va.replace(element);
 						}
 						if (b instanceof CtBlock && ((CtBlock) b).getStatements().size() == 1) {
 							b = ((CtBlock) b).getStatement(0);
 						}
 						l.addStatement(b);
 					}
-					foreach.replace(l);
+					replace(foreach, l);
 					throw new DoNotFurtherTemplateThisElement(foreach);
 				}
 			}
@@ -205,33 +191,36 @@ public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite) {
 			visitFieldAccess(fieldWrite);
 		}
 
-		private <T> void visitFieldAccess(CtFieldAccess<T> fieldAccess) {
+		@SuppressWarnings({ "unchecked", "rawtypes" })
+		private <T> void visitFieldAccess(final CtFieldAccess<T> fieldAccess) {
 			CtFieldReference<?> ref = fieldAccess.getVariable();
 			if ("length".equals(ref.getSimpleName())) {
 				if (fieldAccess.getTarget() instanceof CtFieldAccess) {
 					ref = ((CtFieldAccess<?>) fieldAccess.getTarget()).getVariable();
-					if (Parameters.isParameterSource(ref)) {
-						Object[] value = (Object[]) Parameters.getValue(template, ref.getSimpleName(), null);
-						fieldAccess.replace((CtExpression) fieldAccess.getFactory().Code().createLiteral(value
-								.length));
+					Object value = getParameterValue(ref.getSimpleName());
+					if (value != null) {
+						//the items of this list are not cloned
+						List<Object> list = getParameterValueAsList(Object.class, value);
+						replace(fieldAccess, (CtExpression) fieldAccess.getFactory().Code().createLiteral(list.size()));
 						throw new DoNotFurtherTemplateThisElement(fieldAccess);
 					}
 				}
 			}
-			if (Parameters.isParameterSource(ref)) {
+			Object v = getParameterValue(ref.getSimpleName());
+			if (v != null) {
 				// replace direct field parameter accesses
-				Object value = Parameters.getValue(template, ref.getSimpleName(), Parameters.getIndex(fieldAccess));
+				Object value = getParameterValueAtIndex(Object.class, v, Parameters.getIndex(fieldAccess));
 				CtExpression toReplace = fieldAccess;
 				if (fieldAccess.getParent() instanceof CtArrayAccess) {
 					toReplace = (CtExpression) fieldAccess.getParent();
 				}
 				if (!(value instanceof TemplateParameter)) {
 					if (value instanceof Class) {
-						toReplace.replace(factory.Code()
+						replace(toReplace, factory.Code()
 								.createClassAccess(factory.Type().createReference(((Class<?>) value).getName())));
 					} else if (value instanceof Enum) {
 						CtTypeReference<?> enumType = factory.Type().createReference(value.getClass());
-						toReplace.replace(factory.Code().createVariableRead(
+						replace(toReplace, factory.Code().createVariableRead(
 								factory.Field().createReference(enumType, enumType, ((Enum<?>) value).name()), true));
 					} else if (value instanceof List) {
 						// replace list of CtParameter for generic access to the
@@ -249,12 +238,12 @@ private <T> void visitFieldAccess(CtFieldAccess<T> fieldAccess) {
 							i++;
 						}
 					} else if ((value != null) && value.getClass().isArray()) {
-						toReplace.replace(factory.Code().createLiteralArray((Object[]) value));
+						replace(toReplace, factory.Code().createLiteralArray((Object[]) value));
 					} else {
-						toReplace.replace(factory.Code().createLiteral(value));
+						replace(toReplace, factory.Code().createLiteral(value));
 					}
 				} else {
-					toReplace.clone();
+					replace(toReplace, toReplace.clone());
 				}
 				// do not visit if replaced
 				throw new DoNotFurtherTemplateThisElement(fieldAccess);
@@ -278,24 +267,22 @@ public <T> void visitCtInvocation(CtInvocation<T> invocation) {
 					fa = (CtFieldAccess<?>) ((CtArrayAccess<?, CtExpression<?>>) invocation.getTarget()).getTarget();
 				}
 				if ((fa != null) && (fa.getTarget() == null || fa.getTarget() instanceof CtThisAccess)) {
-					TemplateParameter<?> tparamValue = (TemplateParameter<?>) Parameters
-							.getValue(template, fa.getVariable().getSimpleName(), Parameters.getIndex(fa));
-					CtCodeElement r = null;
-					if (tparamValue != null) {
-						r = ((CtCodeElement) tparamValue).clone();
+					CtCodeElement r = getParameterValueAtIndex(CtCodeElement.class,
+							getParameterValue(fa.getVariable().getSimpleName()), Parameters.getIndex(fa));
+					if (r != null) {
 						// substitute in the replacement (for fixing type
 						// references
 						// and
 						// for recursive substitution)
 						r.accept(parent);
 					}
-					if ((invocation.getParent() instanceof CtReturn) && (r instanceof CtBlock)) {
+					if (invocation.isParentInitialized() && (invocation.getParent() instanceof CtReturn) && (r instanceof CtBlock)) {
 						// block template parameters in returns should
 						// replace
 						// the return
 						((CtReturn<?>) invocation.getParent()).replace((CtStatement) r);
 					} else {
-						invocation.replace(r);
+						replace(invocation, r);
 					}
 				}
 				// do not visit the invocation if replaced
@@ -309,18 +296,11 @@ public <T> void visitCtInvocation(CtInvocation<T> invocation) {
 		public <T> void scanCtExpression(CtExpression<T> expression) {
 			for (int i = 0; i < expression.getTypeCasts().size(); i++) {
 				CtTypeReference<T> t = (CtTypeReference<T>) expression.getTypeCasts().get(i);
-				if (parameterNames.contains(t.getSimpleName())) {
+				CtTypeReference<T> value = getParameterValueAsTypeReference(factory, getParameterValue(t.getSimpleName()));
+				if (value != null) {
 					// replace type parameters
 					// TODO: this would probably not work with inner classes!!!
-					Object o = Parameters.getValue(template, t.getSimpleName(), null);
-					if (o instanceof Class) {
-						t = factory.Type().createReference(((Class<T>) o));
-					} else if (o instanceof CtTypeReference) {
-						t = (CtTypeReference<T>) o;
-						expression.getTypeCasts().set(i, t);
-					} else {
-						throw new RuntimeException("unsupported reference substitution");
-					}
+					expression.getTypeCasts().set(i, value);
 				}
 			}
 			super.scanCtExpression(expression);
@@ -329,25 +309,21 @@ public <T> void scanCtExpression(CtExpression<T> expression) {
 		@SuppressWarnings("unchecked")
 		@Override
 		public <T> void scanCtTypedElement(CtTypedElement<T> e) {
-			if ((e.getType() != null) && parameterNames.contains(e.getType().getSimpleName())) {
-				// replace type parameters
-				// TODO: this would probably not work with inner classes!!!
-				CtTypeReference<T> t;
-				Object o = Parameters.getValue(template, e.getType().getSimpleName(), null);
-				if (o instanceof Class) {
-					o = factory.Type().createReference(((Class<T>) o));
-				}
-				if (o instanceof CtTypeReference) {
-					if ((e.getType() instanceof CtArrayTypeReference) && !(o instanceof CtArrayTypeReference)) {
+			final CtTypeReference<T> typeOfE = e.getType();
+			if (typeOfE != null) {
+				CtTypeReference<T> o = getParameterValueAsTypeReference(factory, getParameterValue(typeOfE.getSimpleName()));
+				if (o != null) {
+					// replace type parameters
+					// TODO: this would probably not work with inner classes!!!
+					CtTypeReference<T> t;
+					if ((typeOfE instanceof CtArrayTypeReference) && !(o instanceof CtArrayTypeReference)) {
 						t = (CtArrayTypeReference<T>) e.getFactory().Type().createArrayReference(
-								(CtTypeReference<?>) o,
-								((CtArrayTypeReference<?>) e.getType()).getDimensionCount());
+								o,
+								((CtArrayTypeReference<?>) typeOfE).getDimensionCount());
 					} else {
 						t = (CtTypeReference<T>) o;
 					}
 					e.setType(t);
-				} else {
-					throw new RuntimeException("unsupported reference substitution");
 				}
 			}
 			super.scanCtTypedElement(e);
@@ -368,46 +344,19 @@ public <T> void visitCtExecutableReference(CtExecutableReference<T> reference) {
 		 */
 		@Override
 		public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
-			// if (reference.equals(templateRef) || (!reference.isPrimitif() &&
-			// f.Type().createReference(Template.class).isAssignableFrom(reference)
-			// && reference.isAssignableFrom(templateRef))) {
-			if (reference.equals(templateRef)) {
-				// replace references to the template type with references
-				// to the targetType (only if the referenced element exists
-				// in the target)
-				reference.setDeclaringType(targetRef.getDeclaringType());
-				reference.setPackage(targetRef.getPackage());
-				reference.setSimpleName(targetRef.getSimpleName());
-			}
-			if (parameterNames.contains(reference.getSimpleName())) {
+			Object o = getParameterValue(reference.getSimpleName());
+			if (o != null) {
 				// replace type parameters
 				// TODO: this would probably not work with inner classes!!!
-				CtTypeReference<?> t;
-				Object o = Parameters.getValue(template, reference.getSimpleName(), null);
-				if (o instanceof Class) {
-					t = factory.Type().createReference(((Class<?>) o));
-				} else if (o instanceof CtTypeReference) {
-					t = ((CtTypeReference<?>) o).clone();
+				boolean paramHasActualTypeArguments = o instanceof CtTypeReference;
+				CtTypeReference<?> t = getParameterValueAsTypeReference(factory, o);
+				if (paramHasActualTypeArguments) {
+					//the origin parameter has actual type arguments, apply them
 					reference.setActualTypeArguments(t.getActualTypeArguments());
-				} else {
-					throw new RuntimeException(
-							"unsupported reference substitution: " + reference.getSimpleName() + " with value " + o);
 				}
 				reference.setPackage(t.getPackage());
 				reference.setSimpleName(t.getSimpleName());
 				reference.setDeclaringType(t.getDeclaringType());
-			} else if (templateTypeRef.isSubtypeOf(reference)) {
-				// this can only be a template inheritance case (to be verified)
-				CtTypeReference<?> sc = targetRef.getSuperclass();
-				if (sc != null) {
-					reference.setDeclaringType(sc.getDeclaringType());
-					reference.setPackage(sc.getPackage());
-					reference.setSimpleName(sc.getSimpleName());
-				} else {
-					reference.setDeclaringType(null);
-					reference.setPackage(factory.Package().createReference("java.lang"));
-					reference.setSimpleName("Object");
-				}
 			}
 			super.visitCtTypeReference(reference);
 		}
@@ -419,47 +368,46 @@ public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
 
 	CtExecutableReference<?> S;
 
-	CtTypeReference<?> targetRef;
-
-	CtType<?> targetType;
-
-	Template<?> template;
-
-	CtTypeReference<? extends Template> templateRef;
-
-	CtTypeReference<Template> templateTypeRef;
-
-	CtClass<? extends Template<?>> templateType;
+	Map<String, Object> namesToValues;
 
-	Collection<String> parameterNames;
+	/**
+	 * represents root element, which is target of the substitution.
+	 * It can be substituted too.
+	 */
+	CtElement result;
 
 	/**
-	 * Creates a new substitution visitor.
+	 * Creates new substitution visitor based on instance of Template,
+	 * which defines template model and template parameters
 	 *
 	 * @param f
 	 * 		the factory
 	 * @param targetType
-	 * 		the target type of the substitution
+	 * 		the target type of the substitution (can be null)
 	 * @param template
 	 * 		the template that holds the parameter values
 	 */
+	@SuppressWarnings({ "unchecked", "rawtypes" })
 	public SubstitutionVisitor(Factory f, CtType<?> targetType, Template<?> template) {
-		inheritanceScanner = new InheritanceSustitutionScanner(this);
-		this.factory = f;
-		this.template = template;
-		this.targetType = targetType;
-		S = f.Executable().createReference(f.Type().createReference(TemplateParameter.class),
-				f.Type().createTypeParameterReference("T"), "S");
-		templateRef = f.Type().createReference(template.getClass());
-		templateType = f.Class().get(templateRef.getQualifiedName());
-		parameterNames = Parameters.getNames(templateType);
-		templateTypeRef = f.Type().createReference(Template.class);
-		if (targetType != null) {
-			targetRef = f.Type().createReference(targetType);
-			// first substitute target ref
-			targetRef.accept(this);
-		}
+		this(f, Parameters.getTemplateParametersAsMap(f, targetType, template));
+	}
 
+	/**
+	 * Creates new substitution visitor
+	 * with substitution model (doesn't have to implement {@link Template}) type
+	 * and the substitution parameters (doesn't have to be bound to {@link TemplateParameter} or {@link Parameter}).
+	 *
+	 * @param f
+	 * 		the factory
+	 * @param templateParameters
+	 * 		the parameter names and values which will be used during substitution
+	 */
+	public SubstitutionVisitor(Factory f, Map<String, Object> templateParameters) {
+		this.inheritanceScanner = new InheritanceSustitutionScanner(this);
+		this.factory = f;
+		S = factory.Executable().createReference(factory.Type().createReference(TemplateParameter.class),
+				factory.Type().createTypeParameterReference("T"), "S");
+		this.namesToValues = templateParameters;
 	}
 
 	/**
@@ -482,4 +430,157 @@ public void scan(CtElement element) {
 		} catch (DoNotFurtherTemplateThisElement ignore) {
 		}
 	}
+
+	/**
+	 * Substitutes all template parameters of element and returns substituted element.
+	 *
+	 * @param element to be substituted model
+	 * @return substituted model
+	 */
+	public <E extends CtElement> E substitute(E element) {
+		result = element;
+		scan(element);
+		return (E) result;
+	}
+
+	private void replace(CtElement toBeReplaced, CtElement replacement) {
+		if (result == toBeReplaced) {
+			result = replacement;
+		} else {
+			toBeReplaced.replace(replacement);
+		}
+	}
+
+	private Object getParameterValue(String parameterName) {
+		return namesToValues.get(parameterName);
+	}
+	/**
+	 * 1) Converts `parameterValue` to List using these rules
+	 * <ul>
+	 * <li>Array is converted to List .
+	 * <li>{@link Iterable} is converted to List .
+	 * <li>Single item is add to list.
+	 * </ul>
+	 * 2) assures that each list item has expected type `itemClass`
+	 * 3) if itemClass is sub type of CtElement then clones it
+	 *
+	 * @param itemClass the type of the items of resulting list.
+	 * 	If some item cannot be converted to the itemClass then {@link SpoonException} is thrown
+	 * @param parameterValue a value of an template parameter
+	 * @return list where each item is assured to be of type itemClass
+	 */
+	@SuppressWarnings("unchecked")
+	private static <T> List<T> getParameterValueAsList(Class<T> itemClass, Object parameterValue) {
+		if (parameterValue == null) {
+			return null;
+		}
+		List<T> list = new ArrayList<>();
+		if (parameterValue instanceof Object[]) {
+			for (T item : (T[]) parameterValue) {
+				list.add(getParameterValueAsClass(itemClass, item));
+			}
+		} else if (parameterValue instanceof Iterable) {
+			for (T item : (Iterable<T>) parameterValue) {
+				list.add(getParameterValueAsClass(itemClass, item));
+			}
+		} else {
+			list.add(getParameterValueAsClass(itemClass, parameterValue));
+		}
+		return list;
+	}
+	/**
+	 * 1) Assures that parameterValue has expected type `itemClass`
+	 * 2) if itemClass is sub type of CtElement then clones parameterValue
+	 *
+	 * @param itemClass required return class
+	 * @param parameterValue a value of an template parameter
+	 * @return parameterValue cast (in future potentially converted) to itemClass
+	 */
+	@SuppressWarnings("unchecked")
+	private static <T> T getParameterValueAsClass(Class<T> itemClass, Object parameterValue) {
+		if (parameterValue == null) {
+			return null;
+		}
+
+		if (itemClass.isInstance(parameterValue)) {
+			if (CtElement.class.isAssignableFrom(itemClass)) {
+				/*
+				 * the cloning is defined by itemClass and not by parameterValue,
+				 * because there are cases when we do not want to clone parameterValue.
+				 * In this case itemClass == Object.class
+				 */
+				parameterValue = ((CtElement) parameterValue).clone();
+			}
+			return (T) parameterValue;
+		}
+		throw new SpoonException("Parameter value has unexpected class: " + parameterValue.getClass().getName() + ". Expected class is: " + itemClass.getName());
+	}
+	/**
+	 * @param parameterValue a value of an template parameter
+	 * @return parameter value converted to String
+	 */
+	private static String getParameterValueAsString(Object parameterValue) {
+		if (parameterValue == null) {
+			return null;
+		}
+		if (parameterValue instanceof String) {
+			return (String) parameterValue;
+		} else if (parameterValue instanceof CtNamedElement) {
+			return ((CtNamedElement) parameterValue).getSimpleName();
+		} else if (parameterValue instanceof CtReference) {
+			return ((CtReference) parameterValue).getSimpleName();
+		}
+		throw new SpoonException("Parameter value has unexpected class: " + parameterValue.getClass().getName() + ", whose conversion to String is not supported");
+	}
+
+	/**
+	 * Converts `parameterValue` to {@link CtTypeReference}.
+	 * It assures that new reference is returned.
+	 * If parameterValue is already a {@link CtTypeReference}, then it is cloned.
+	 *
+	 * @param factory a Spoon factory used to create CtTypeReference instance - if needed
+	 * @param parameterValue a value of an template parameter
+	 * @return parameter value converted to {@link CtTypeReference}
+	 */
+	@SuppressWarnings("unchecked")
+	private static <T> CtTypeReference<T> getParameterValueAsTypeReference(Factory factory, Object parameterValue) {
+		if (parameterValue == null) {
+			return null;
+		}
+		if (parameterValue instanceof Class) {
+			return factory.Type().createReference((Class<T>) parameterValue);
+		} else if (parameterValue instanceof CtTypeReference) {
+			return ((CtTypeReference<T>) parameterValue).clone();
+		} else if (parameterValue instanceof CtType) {
+			return ((CtType<T>) parameterValue).getReference();
+		} else if (parameterValue instanceof String) {
+			return factory.Type().createReference((String) parameterValue);
+		} else {
+			throw new RuntimeException("unsupported reference substitution");
+		}
+	}
+
+	/**
+	 * 1a) If index is null, then parameterValue must be a single item, which will be converted to itemClass
+	 * 1b) If index is a number, then parameterValue is converted to List, the index-th item is converted to itemClass
+	 * 2) if itemClass is sub type of CtElement then returned element is a clone
+	 *
+	 * @param itemClass required return class
+	 * @param parameterValue a value of an template parameter
+	 * @param index index of item from the list, or null if item is not expected to be a list
+	 * @return parameterValue (optionally item from the list) cast (in future potentially converted) to itemClass
+	 */
+	private static <T> T getParameterValueAtIndex(Class<T> itemClass, Object parameterValue, Integer index) {
+		if (index != null) {
+			//convert to list, but do not clone
+			List<Object> list = getParameterValueAsList(Object.class, parameterValue);
+			if (list.size() > index) {
+				//convert and clone the returned item
+				return getParameterValueAsClass(itemClass, list.get(index));
+			}
+			return null;
+		}
+		//convert and clone the returned item
+		return getParameterValueAsClass(itemClass, parameterValue);
+	}
 }
diff --git a/src/main/java/spoon/template/StatementTemplate.java b/src/main/java/spoon/template/StatementTemplate.java
index 8835bb7bc02..906565d1136 100644
--- a/src/main/java/spoon/template/StatementTemplate.java
+++ b/src/main/java/spoon/template/StatementTemplate.java
@@ -43,8 +43,7 @@ public CtStatement apply(CtType<?> targetType) {
 		CtClass<?> c = Substitution.getTemplateCtClass(targetType, this);
 		// we substitute the first statement of method statement
 		CtStatement result = c.getMethod("statement").getBody().getStatements().get(0).clone();
-		new SubstitutionVisitor(c.getFactory(), targetType, this).scan(result);
-		return result;
+		return new SubstitutionVisitor(c.getFactory(), targetType, this).substitute(result);
 	}
 
 	public Void S() {
diff --git a/src/main/java/spoon/template/Substitution.java b/src/main/java/spoon/template/Substitution.java
index 966fbd43de9..a299af65e30 100644
--- a/src/main/java/spoon/template/Substitution.java
+++ b/src/main/java/spoon/template/Substitution.java
@@ -29,6 +29,7 @@
 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.CtTypeMember;
 import spoon.reflect.factory.Factory;
@@ -40,7 +41,9 @@
 import spoon.support.template.SubstitutionVisitor;
 
 import java.lang.reflect.Field;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * This class defines the substitution API for templates (see {@link Template}).
@@ -82,6 +85,37 @@ public static <T extends Template<?>> void insertAll(CtType<?> targetType, T tem
 		}
 	}
 
+	/**
+	 * Generates a type (class, interface, enum, ...) from the template model `templateOfType`
+	 * by by substituting all the template parameters by their values.
+	 *
+	 * Inserts all the methods, fields, constructors, initialization blocks (if
+	 * target is a class), inner types, super class and super interfaces.
+	 *
+	 * Note!
+	 * This algorithm does NOT handle interfaces or annotations
+	 * {@link Template}, {@link spoon.template.Local}, {@link TemplateParameter} or {@link Parameter}
+	 * in a special way, it means they all will be added to the generated type too.
+	 * If you do not want to add them then clone your templateOfType and remove these nodes from that model before.
+	 *
+	 * @param targetPackage
+	 * 		the package where the new type will be added
+	 * @param typeName
+	 * 		the simple name of the new type
+	 * @param templateOfType
+	 * 		the model used as source of generation.
+	 * @param templateParameters
+	 * 		the substitution parameters
+	 */
+	public static <T> CtType<T> insertType(CtPackage targetPackage, String typeName, CtType<T> templateOfType, Map<String, Object> templateParameters) {
+		final Factory f = templateOfType.getFactory();
+		final Map<String, Object> extendedParams = new HashMap<String, Object>(templateParameters);
+		extendedParams.put(templateOfType.getSimpleName(), f.Type().createReference(targetPackage.getQualifiedName() + "." + typeName));
+		CtType<T> generated = new SubstitutionVisitor(f, extendedParams).substitute(templateOfType.clone());
+		targetPackage.addType(generated);
+		return generated;
+	}
+
 	/**
 	 * Inserts all the super interfaces (except {@link Template}) from a given
 	 * template by substituting all the template parameters by their values.
@@ -484,8 +518,7 @@ public static <E extends CtElement> E substitute(CtType<?> targetType, Template<
 			throw new RuntimeException("target is null in substitution");
 		}
 		E result = (E) code.clone();
-		new SubstitutionVisitor(targetType.getFactory(), targetType, template).scan(result);
-		return result;
+		return new SubstitutionVisitor(targetType.getFactory(), targetType, template).substitute(result);
 	}
 
 	/**
@@ -532,8 +565,7 @@ public static <T extends CtType<?>> T substitute(Template<?> template, T templat
 		T result = (T) templateType.clone();
 		result.setPositions(null);
 		// result.setParent(templateType.getParent());
-		new SubstitutionVisitor(templateType.getFactory(), result, template).scan(result);
-		return result;
+		return new SubstitutionVisitor(templateType.getFactory(), result, template).substitute(result);
 	}
 
 	/**
diff --git a/src/test/java/spoon/test/template/TemplateTest.java b/src/test/java/spoon/test/template/TemplateTest.java
index 49b89e73f3c..151de3ccf87 100644
--- a/src/test/java/spoon/test/template/TemplateTest.java
+++ b/src/test/java/spoon/test/template/TemplateTest.java
@@ -11,19 +11,27 @@
 import spoon.reflect.code.CtTry;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtElement;
+import spoon.reflect.declaration.CtEnum;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
+import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.visitor.ModelConsistencyChecker;
 import spoon.reflect.visitor.filter.NameFilter;
 import spoon.support.compiler.FileSystemFile;
+import spoon.support.compiler.FileSystemFolder;
 import spoon.support.template.Parameters;
+import spoon.support.template.SubstitutionVisitor;
+import spoon.template.Substitution;
 import spoon.template.TemplateMatcher;
 import spoon.template.TemplateParameter;
 import spoon.test.template.testclasses.ArrayAccessTemplate;
 import spoon.test.template.testclasses.InvocationTemplate;
+import spoon.test.template.testclasses.LoggerModel;
 import spoon.test.template.testclasses.SecurityCheckerTemplate;
+import spoon.test.template.testclasses.SubstituteRootTemplate;
 import spoon.test.template.testclasses.bounds.CheckBound;
 import spoon.test.template.testclasses.bounds.CheckBoundMatcher;
 import spoon.test.template.testclasses.bounds.CheckBoundTemplate;
@@ -38,17 +46,25 @@
 import spoon.test.template.testclasses.inheritance.SuperTemplate;
 import spoon.test.template.testclasses.logger.Logger;
 import spoon.test.template.testclasses.logger.LoggerTemplateProcessor;
+import spoon.test.template.testclasses.types.AClassModel;
+import spoon.test.template.testclasses.types.AnEnumModel;
+import spoon.test.template.testclasses.types.AnIfaceModel;
 
 import java.io.File;
 import java.io.Serializable;
 import java.rmi.Remote;
+import java.security.GeneralSecurityException;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.fail;
@@ -359,6 +375,36 @@ public void testExtensionBlock() throws Exception {
 		assertTrue(aTry.getBody().getStatements().size() > 1);
 	}
 
+	@Test
+	public void testExtensionDecoupledSubstitutionVisitor() throws Exception {
+		final Launcher launcher = new Launcher();
+		launcher.setArgs(new String[] {"--output-type", "nooutput" });
+		launcher.addInputResource("./src/test/java/spoon/test/template/testclasses/logger/Logger.java");
+		launcher.addTemplateResource(new FileSystemFile("./src/test/java/spoon/test/template/testclasses/LoggerModel.java"));
+
+		launcher.buildModel();
+		Factory factory = launcher.getFactory();
+
+		final CtClass<?> aTemplateModelType = launcher.getFactory().Class().get(LoggerModel.class);
+		final CtMethod<?> aTemplateModel = aTemplateModelType.getMethod("block");
+		final CtClass<?> aTargetType = launcher.getFactory().Class().get(Logger.class);
+		final CtMethod<?> toBeLoggedMethod = aTargetType.getMethodsByName("enter").get(0);
+
+		
+		Map<String, Object> params = new HashMap<>();
+		params.put("_classname_", aTargetType.getSimpleName()) ;
+		params.put("_methodName_", toBeLoggedMethod.getSimpleName());
+		params.put("_block_", toBeLoggedMethod.getBody());
+		final CtMethod<?> aMethod = new SubstitutionVisitor(factory, params).substitute(aTemplateModel.clone());
+		assertTrue(aMethod.getBody().getStatement(0) instanceof CtTry);
+		final CtTry aTry = (CtTry) aMethod.getBody().getStatement(0);
+		assertTrue(aTry.getFinalizer().getStatement(0) instanceof CtInvocation);
+		assertEquals("spoon.test.template.testclasses.logger.Logger.exit(\"enter\")", aTry.getFinalizer().getStatement(0).toString());
+		assertTrue(aTry.getBody().getStatement(0) instanceof CtInvocation);
+		assertEquals("spoon.test.template.testclasses.logger.Logger.enter(\"Logger\", \"enter\")", aTry.getBody().getStatement(0).toString());
+		assertTrue(aTry.getBody().getStatements().size() > 1);
+	}
+
 	@Test
 	public void testTemplateInterfaces() throws Exception {
 		Launcher spoon = new Launcher();
@@ -503,4 +549,72 @@ public void testTemplateArrayAccess() throws Exception {
 		CtMethod<?> m2 = resultKlass.getMethod("method2");
 		assertEquals("java.lang.System.out.println(\"second\")", m2.getBody().getStatement(0).toString());
 	}
+
+	@Test
+	public void testStatementTemplateRootSubstitution() throws Exception {
+		//contract: the template engine supports substitution of root element
+		Launcher spoon = new Launcher();
+		spoon.addTemplateResource(new FileSystemFile("./src/test/java/spoon/test/template/testclasses/SubstituteRootTemplate.java"));
+
+		spoon.buildModel();
+		Factory factory = spoon.getFactory();
+
+		CtClass<?> templateClass = factory.Class().get(SubstituteRootTemplate.class);
+		CtBlock<Void> param = (CtBlock) templateClass.getMethod("sampleBlock").getBody();
+		
+		CtClass<?> resultKlass = factory.Class().create("Result");
+		CtStatement result = new SubstituteRootTemplate(param).apply(resultKlass);
+		assertEquals("java.lang.String s = \"Spoon is cool!\"", ((CtBlock)result).getStatement(0).toString());
+	}
+
+	@Test
+	public void testInsertType() throws Exception {
+		final Launcher launcher = new Launcher();
+		launcher.setArgs(new String[] {"--output-type", "nooutput" });
+		launcher.addTemplateResource(new FileSystemFolder("./src/test/java/spoon/test/template/testclasses/types"));
+
+		launcher.buildModel();
+		Factory factory = launcher.getFactory();
+		
+		CtPackage targetPackage = factory.Package().create(factory.getModel().getRootPackage(), "generated");
+		factory.getModel().getRootPackage().addPackage(targetPackage);
+
+		
+		Map<String, Object> parameters = new HashMap<>();
+		//replace someMethod with genMethod
+		parameters.put("someMethod", "genMethod");
+		
+		//contract: we can generate interface
+		final CtType<?> aIfaceModel = launcher.getFactory().Interface().get(AnIfaceModel.class);
+		CtType<?> genIface = Substitution.insertType(targetPackage, "GenIface", aIfaceModel, parameters);
+		assertNotNull(genIface);
+		assertSame(genIface, factory.Type().get("generated.GenIface"));
+		CtMethod<?> generatedIfaceMethod = genIface.getMethod("genMethod");
+		assertNotNull(generatedIfaceMethod);
+		assertNull(genIface.getMethod("someMethod"));
+
+		//add new substitution request - replace AnIfaceModel by GenIface
+		parameters.put("AnIfaceModel", genIface.getReference());
+		//contract: we can generate class
+		final CtType<?> aClassModel = launcher.getFactory().Class().get(AClassModel.class);
+		CtType<?> genClass = Substitution.insertType(targetPackage, "GenClass", aClassModel, parameters);
+		assertNotNull(genClass);
+		assertSame(genClass, factory.Type().get("generated.GenClass"));
+		CtMethod<?> generatedClassMethod = genClass.getMethod("genMethod");
+		assertNotNull(generatedClassMethod);
+		assertNull(genClass.getMethod("someMethod"));
+		assertTrue(generatedIfaceMethod!=generatedClassMethod);
+		assertTrue(generatedClassMethod.isOverriding(generatedIfaceMethod));
+		
+		//contract: we can generate enum
+		parameters.put("case1", "GOOD");
+		parameters.put("case2", "BETTER");
+		final CtType<?> aEnumModel = launcher.getFactory().Type().get(AnEnumModel.class);
+		CtEnum<?> genEnum = (CtEnum<?>) Substitution.insertType(targetPackage, "GenEnum", aEnumModel, parameters);
+		assertNotNull(genEnum);
+		assertSame(genEnum, factory.Type().get("generated.GenEnum"));
+		assertEquals(2, genEnum.getEnumValues().size());
+		assertEquals("GOOD", genEnum.getEnumValues().get(0).getSimpleName());
+		assertEquals("BETTER", genEnum.getEnumValues().get(1).getSimpleName());
+	}
 }
diff --git a/src/test/java/spoon/test/template/testclasses/LoggerModel.java b/src/test/java/spoon/test/template/testclasses/LoggerModel.java
new file mode 100644
index 00000000000..02a7399224e
--- /dev/null
+++ b/src/test/java/spoon/test/template/testclasses/LoggerModel.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2006-2015 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.test.template.testclasses;
+
+import spoon.reflect.code.CtBlock;
+import spoon.test.template.testclasses.logger.Logger;
+
+public class LoggerModel {
+	private String _classname_;
+	private String _methodName_;
+	private CtBlock<?> _block_;
+
+	public void block() throws Throwable {
+		try {
+			Logger.enter(_classname_, _methodName_);
+			_block_.S();
+		} finally {
+			Logger.exit(_methodName_);
+		}
+	}
+}
diff --git a/src/test/java/spoon/test/template/testclasses/SubstituteRootTemplate.java b/src/test/java/spoon/test/template/testclasses/SubstituteRootTemplate.java
new file mode 100644
index 00000000000..8c9d8018eb5
--- /dev/null
+++ b/src/test/java/spoon/test/template/testclasses/SubstituteRootTemplate.java
@@ -0,0 +1,28 @@
+package spoon.test.template.testclasses;
+
+import spoon.reflect.code.CtBlock;
+import spoon.template.Local;
+import spoon.template.Parameter;
+import spoon.template.StatementTemplate;
+import spoon.template.TemplateParameter;
+
+public class SubstituteRootTemplate extends StatementTemplate {
+
+	@Override
+	public void statement() throws Throwable {
+		block.S();
+	}
+	
+	@Parameter
+	TemplateParameter<Void> block;
+
+	@Local
+	public SubstituteRootTemplate(CtBlock<Void> block) {
+		this.block = block;
+	}
+	
+	@Local
+	void sampleBlock() {
+		String s="Spoon is cool!";
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/spoon/test/template/testclasses/types/AClassModel.java b/src/test/java/spoon/test/template/testclasses/types/AClassModel.java
new file mode 100644
index 00000000000..897c2d35efe
--- /dev/null
+++ b/src/test/java/spoon/test/template/testclasses/types/AClassModel.java
@@ -0,0 +1,23 @@
+package spoon.test.template.testclasses.types;
+
+import java.util.AbstractList;
+
+public class AClassModel<E> extends AbstractList<E> implements AnIfaceModel {
+
+	public AClassModel() {
+	}
+	
+	@Override
+	public E get(int index) {
+		throw new IndexOutOfBoundsException();
+	}
+
+	@Override
+	public int size() {
+		return 0;
+	}
+
+	@Override
+	public void someMethod() {
+	}
+}
diff --git a/src/test/java/spoon/test/template/testclasses/types/AnEnumModel.java b/src/test/java/spoon/test/template/testclasses/types/AnEnumModel.java
new file mode 100644
index 00000000000..795506ea42b
--- /dev/null
+++ b/src/test/java/spoon/test/template/testclasses/types/AnEnumModel.java
@@ -0,0 +1,5 @@
+package spoon.test.template.testclasses.types;
+
+public enum AnEnumModel {
+	case1, case2;
+}
diff --git a/src/test/java/spoon/test/template/testclasses/types/AnIfaceModel.java b/src/test/java/spoon/test/template/testclasses/types/AnIfaceModel.java
new file mode 100644
index 00000000000..90a23086afd
--- /dev/null
+++ b/src/test/java/spoon/test/template/testclasses/types/AnIfaceModel.java
@@ -0,0 +1,7 @@
+package spoon.test.template.testclasses.types;
+
+import java.io.Serializable;
+
+public interface AnIfaceModel extends Serializable {
+	void someMethod();
+}