test: add test for template substitution of enum values (#1389)

* test SubstitutionVisitor enum value replace

* fix SubstitutionVisitor enum value replace

* check generated code

* fix variable name and create enum class reference in tmpl constructor

src/main/java/spoon/support/template/SubstitutionVisitor.java

@@ -231,8 +231,10 @@ private <T> void visitFieldAccess(CtFieldAccess<T> fieldAccess) {
 								.createClassAccess(factory.Type().createReference(((Class<?>) value).getName())));
 					} else if (value instanceof Enum) {
 						CtTypeReference<?> enumType = factory.Type().createReference(value.getClass());
-						toReplace.replace(factory.Code().createVariableRead(
-								factory.Field().createReference(enumType, enumType, ((Enum<?>) value).name()), true));
+						CtFieldRead<T> enumValueAccess = (CtFieldRead<T>) factory.Code().createVariableRead(
+								factory.Field().createReference(enumType, enumType, ((Enum<?>) value).name()), true);
+						enumValueAccess.setTarget(factory.Code().createTypeAccess(enumType));
+						toReplace.replace(enumValueAccess);
 					} else if (value instanceof List) {
 						// replace list of CtParameter for generic access to the
 						// parameters

src/test/java/spoon/test/template/TemplateEnumAccessTest.java

@@ -0,0 +1,37 @@
+package spoon.test.template;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.lang.annotation.ElementType;
+
+import org.junit.Test;
+
+import spoon.Launcher;
+import spoon.OutputType;
+import spoon.reflect.declaration.CtClass;
+import spoon.reflect.factory.Factory;
+import spoon.support.compiler.FileSystemFile;
+import spoon.test.template.testclasses.EnumAccessTemplate;
+import spoon.testing.utils.ModelUtils;
+
+public class TemplateEnumAccessTest {
+
+	@Test
+	public void testEnumAccessTest() throws Exception {
+		//contract: the template engine supports enum value access substitution
+		Launcher launcher = new Launcher();
+		launcher.addTemplateResource(new FileSystemFile("./src/test/java/spoon/test/template/testclasses/EnumAccessTemplate.java"));
+
+		launcher.buildModel();
+		Factory factory = launcher.getFactory();
+
+		CtClass<?> resultKlass = factory.Class().create(factory.Package().getOrCreate("spoon.test.template"), "EnumAccessResult");
+		new EnumAccessTemplate(ElementType.FIELD, launcher.getFactory()).apply(resultKlass);
+		assertEquals("java.lang.annotation.ElementType.FIELD.name()", resultKlass.getMethod("method").getBody().getStatement(0).toString());
+		launcher.setSourceOutputDirectory(new File("./target/spooned/"));
+		launcher.getModelBuilder().generateProcessedSourceFiles(OutputType.CLASSES);
+		ModelUtils.canBeBuilt(new File("./target/spooned/spoon/test/template/EnumAccessResult.java"), 8);
+	}
+
+}

src/test/java/spoon/test/template/testclasses/EnumAccessTemplate.java

@@ -0,0 +1,32 @@
+package spoon.test.template.testclasses;
+
+import spoon.reflect.factory.Factory;
+import spoon.reflect.reference.CtTypeReference;
+import spoon.template.ExtensionTemplate;
+import spoon.template.Local;
+import spoon.template.Parameter;
+
+public class EnumAccessTemplate extends ExtensionTemplate {
+
+	public void method() throws Throwable {
+		_AnEnum_._value_.name();
+	}
+
+	@Parameter("_AnEnum_")
+	CtTypeReference<?> anEnum;
+
+	@Parameter
+	Enum _value_;
+
+	@Local
+	public EnumAccessTemplate(Enum enumValue, Factory factory) {
+		this._value_ = enumValue;
+		this.anEnum = factory.Type().createReference(enumValue.getClass()); 
+	}
+
+	@Local
+	enum _AnEnum_ {
+		@Parameter
+		_value_
+	}
+}