feature: one can get annotation values directly

src/main/java/spoon/reflect/declaration/CtAnnotation.java

@@ -68,7 +68,10 @@ public interface CtAnnotation<A extends Annotation> extends CtExpression<A>, CtS
 	CtTypeReference<A> getAnnotationType();
 
 	/**
-	 * Gets a value for a given key without any conversion.
+	 * Gets a value, as a CtExpression, for a given key without any conversion.
+	 *
+	 * If you need the actual value (eg an integer and not a literal, see {@link #getValueAsObject(String)} and similar methods.
+	 *
 	 * Note that this value type does not necessarily corresponds to the annotation
 	 * type member. For example, in case the annotation type expect an array of Object,
 	 * and a single value is given, Spoon will return only the object without the CtNewArray.
@@ -81,6 +84,18 @@ public interface CtAnnotation<A extends Annotation> extends CtExpression<A>, CtS
 	@PropertyGetter(role = VALUE)
 	<T extends CtExpression> T getValue(String key);
 
+	/** Returns the actual value of an annotation property */
+	@DerivedProperty
+	Object getValueAsObject(String key);
+
+	/** Returns the actual value of an annotation property, as an integer (utility method) */
+	@DerivedProperty
+	int getValueAsInt(String key);
+
+	/** Returns the actual value of an annotation property, as a String (utility method) */
+	@DerivedProperty
+	String getValueAsString(String key);
+
 	/**
 	 * Gets a value for a given key and try to fix its type based on the
 	 * annotation type. For example, if the annotation type member expects an array of String,

src/main/java/spoon/support/reflect/declaration/CtAnnotationImpl.java

@@ -312,7 +312,22 @@ public <T extends CtExpression> T getValue(String key) {
 		return (T) getValueAsExpression(key);
 	}
 
-	private Object getValueAsObject(String key) {
+	@Override
+	public int getValueAsInt(String key) {
+		Object val = getValueAsObject(key);
+		if (val == null) {
+			throw new IllegalStateException(key + " not in the annotation");
+		}
+		return (int) val;
+	}
+
+	@Override
+	public String getValueAsString(String key) {
+		return (String) getValueAsObject(key);
+	}
+
+	@Override
+	public Object getValueAsObject(String key) {
 		CtExpression expr = getWrappedValue(key);
 		Object ret = convertElementToRuntimeObject(expr);
 		Class<?> type = getElementType(key);

src/test/java/spoon/test/annotation/AnnotationTest.java

@@ -199,13 +199,16 @@ public void testAnnotationParameterTypes() throws Exception {
 
 		CtAnnotation<?> a = annotations.get(0);
 		AnnotParamTypes annot = (AnnotParamTypes) a.getActualAnnotation();
+		assertEquals(42, a.getValueAsInt("integer"));
 		assertEquals(42, annot.integer());
 		assertEquals(1, annot.integers().length);
 		assertEquals(42, annot.integers()[0]);
+		assertEquals("Hello World!", a.getValueAsString("string"));
 		assertEquals("Hello World!", annot.string());
 		assertEquals(2, annot.strings().length);
 		assertEquals("Hello", annot.strings()[0]);
 		assertEquals("World", annot.strings()[1]);
+		assertEquals(Integer.class, a.getValueAsObject("clazz"));
 		assertEquals(Integer.class, annot.clazz());
 		assertEquals(2, annot.classes().length);
 		assertEquals(Integer.class, annot.classes()[0]);