feat(snippet): add support for compiling statements with return

src/main/java/spoon/reflect/code/CtCodeSnippetStatement.java

@@ -17,6 +17,7 @@
 package spoon.reflect.code;
 
 import spoon.reflect.declaration.CtCodeSnippet;
+import spoon.reflect.reference.CtTypeReference;
 import spoon.support.compiler.SnippetCompilationError;
 
 /**
@@ -31,6 +32,9 @@ public interface CtCodeSnippetStatement extends CtStatement, CtCodeSnippet {
 	 * Compiles this statement code snippet to produce the corresponding AST
 	 * statement.
 	 *
+	 * If you want to compile a non-void return or a snippet that uses a non-void  return,
+	 * use, {@link spoon.support.compiler.SnippetCompilationHelper#compileStatement(CtCodeSnippetStatement, CtTypeReference)}
+	 *
 	 * @return a statement
 	 * @throws SnippetCompilationError
 	 * 		when the current snippet is not valid Java code

src/main/java/spoon/support/compiler/SnippetCompilationHelper.java

@@ -62,13 +62,18 @@ public static void compileAndReplaceSnippetsIn(CtType<?> c) {
 
 	public static CtStatement compileStatement(CtCodeSnippetStatement st)
 			throws SnippetCompilationError {
-		return internalCompileStatement(st);
+		return internalCompileStatement(st, st.getFactory().Type().VOID_PRIMITIVE);
 	}
 
-	private static CtStatement internalCompileStatement(CtElement st) {
+	public static CtStatement compileStatement(CtCodeSnippetStatement st, CtTypeReference returnType)
+			throws SnippetCompilationError {
+		return internalCompileStatement(st, returnType);
+	}
+
+	private static CtStatement internalCompileStatement(CtElement st, CtTypeReference returnType) {
 		Factory f = st.getFactory();
 
-		CtClass<?> w = createWrapper(st, f);
+		CtClass<?> w = createWrapper(st, f, returnType);
 
 		build(f, w);
 
@@ -97,7 +102,7 @@ private static CtStatement internalCompileStatement(CtElement st) {
 	public static <T> CtExpression<T> compileExpression(
 			CtCodeSnippetExpression<T> expr) throws SnippetCompilationError {
 
-		CtReturn<T> ret = (CtReturn<T>) internalCompileStatement(expr);
+		CtReturn<T> ret = (CtReturn<T>) internalCompileStatement(expr, expr.getFactory().Type().OBJECT);
 
 		return ret.getReturnedExpression();
 	}
@@ -119,22 +124,20 @@ private static void build(Factory f, String contents) {
 		}
 	}
 
-	private static CtClass<?> createWrapper(CtElement element, Factory f) {
+	private static CtClass<?> createWrapper(final CtElement element, final Factory f, final CtTypeReference returnType) {
 		CtClass<?> w = f.Class().create(WRAPPER_CLASS_NAME);
 
 		// Clean up (delete wrapper from factory)
 		w.getPackage().getTypes().remove(w);
 
 		CtBlock body = f.Core().createBlock();
-
-		CtTypeReference returnType = f.Type().VOID_PRIMITIVE;
+;
 		if (element instanceof CtStatement) {
 			body.addStatement((CtStatement) element);
 		} else if (element instanceof CtExpression) {
 			CtReturn ret = f.Core().createReturn();
 			ret.setReturnedExpression((CtExpression) element);
 			body.addStatement(ret);
-			returnType = f.Type().OBJECT;
 		}
 
 		Set<ModifierKind> modifiers = EnumSet.of(ModifierKind.STATIC);

src/main/java/spoon/support/compiler/jdt/JDTSnippetCompiler.java

@@ -98,7 +98,9 @@ protected boolean buildSources(JDTBuilder jdtBuilder) {
 
 	@Override
 	protected void report(Environment environment, CategorizedProblem problem) {
-		throw new SnippetCompilationError(problem.getMessage() + "at line " + problem.getSourceLineNumber());
+		if (problem.isError()) {
+			throw new SnippetCompilationError(problem.getMessage() + "at line " + problem.getSourceLineNumber());
+		}
 	}
 
 	/**

src/test/java/spoon/test/snippets/SnippetTest.java

@@ -4,13 +4,17 @@
 import spoon.reflect.code.CtBinaryOperator;
 import spoon.reflect.code.CtCodeSnippetExpression;
 import spoon.reflect.code.CtExpression;
+import spoon.reflect.code.CtReturn;
 import spoon.reflect.declaration.CtClass;
+import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.factory.Factory;
+import spoon.support.compiler.SnippetCompilationHelper;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static spoon.support.compiler.SnippetCompilationHelper.compileStatement;
 import static spoon.testing.utils.ModelUtils.createFactory;
 
 public class SnippetTest {
@@ -76,4 +80,16 @@ public void testCompileSnippetWithContext() throws Exception {
 			fail();
 		}
 	}
+
+	@Test
+	public void testCompileStatementWithReturn() throws Exception {
+		// contract: a snippet with return can be compiled.
+		CtElement el = SnippetCompilationHelper.compileStatement(
+				factory.Code().createCodeSnippetStatement("return 3"),
+				factory.Type().INTEGER
+		);
+		assertTrue(CtReturn.class.isAssignableFrom(el.getClass()));
+		assertEquals("return 3", el.toString());
+	}
+
 }