Move tests for full inliner.

9 files changed, 205 insertions, 175 deletions

diff --git a/test/libjulia/Inliner.cpp b/test/libjulia/Inliner.cpp
index 165e23ad..95b61b29 100644
--- a/test/libjulia/Inliner.cpp
+++ b/test/libjulia/Inliner.cpp
@@ -55,14 +55,6 @@ string inlinableFunctions(string const& _source)
 	);
 }
 
-string fullInline(string const& _source, bool _yul = true)
-{
-	Block ast = disambiguate(_source, _yul);
-	(FunctionHoister{})(ast);
-	(FunctionGrouper{})(ast);\
-	FullInliner(ast).run();
-	return assembly::AsmPrinter(_yul)(ast);
-}
 }
 
 
@@ -117,170 +109,3 @@ BOOST_AUTO_TEST_CASE(negative)
 
 
 BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(YulFullInliner)
-
-BOOST_AUTO_TEST_CASE(simple)
-{
-	BOOST_CHECK_EQUAL(
-		fullInline("{"
-			"function f(a) -> x { let r := mul(a, a) x := add(r, r) }"
-			"let y := add(f(sload(mload(2))), mload(7))"
-		"}", false),
-		format("{"
-			"{"
-				"let _1 := mload(7)"
-				"let f_a := sload(mload(2))"
-				"let f_x"
-				"{"
-					"let f_r := mul(f_a, f_a)"
-					"f_x := add(f_r, f_r)"
-				"}"
-				"let y := add(f_x, _1)"
-			"}"
-			"function f(a) -> x"
-			"{"
-				"let r := mul(a, a)"
-				"x := add(r, r)"
-			"}"
-		"}", false)
-	);
-}
-
-BOOST_AUTO_TEST_CASE(multi_fun)
-{
-	BOOST_CHECK_EQUAL(
-		fullInline("{"
-			"function f(a) -> x { x := add(a, a) }"
-			"function g(b, c) -> y { y := mul(mload(c), f(b)) }"
-			"let y := g(f(3), 7)"
-		"}", false),
-		format("{"
-			"{"
-				"let g_c := 7 "
-				"let f_a_1 := 3 "
-				"let f_x_1 "
-				"{ f_x_1 := add(f_a_1, f_a_1) } "
-				"let g_y "
-				"{"
-					"let g_f_a := f_x_1 "
-					"let g_f_x "
-					"{"
-						"g_f_x := add(g_f_a, g_f_a)"
-					"}"
-					"g_y := mul(mload(g_c), g_f_x)"
-				"}"
-				"let y_1 := g_y"
-			"}"
-			"function f(a) -> x"
-			"{"
-				"x := add(a, a)"
-			"}"
-			"function g(b, c) -> y"
-			"{"
-				"let f_a := b "
-				"let f_x "
-				"{"
-					"f_x := add(f_a, f_a)"
-				"}"
-				"y := mul(mload(c), f_x)"
-			"}"
-		"}", false)
-	);
-}
-
-BOOST_AUTO_TEST_CASE(move_up_rightwards_arguments)
-{
-	BOOST_CHECK_EQUAL(
-		fullInline("{"
-			"function f(a, b, c) -> x { x := add(a, b) x := mul(x, c) }"
-			"let y := add(mload(1), add(f(mload(2), mload(3), mload(4)), mload(5)))"
-		"}", false),
-		format("{"
-			"{"
-				"let _1 := mload(5)"
-				"let f_c := mload(4)"
-				"let f_b := mload(3)"
-				"let f_a := mload(2)"
-				"let f_x"
-				"{"
-					"f_x := add(f_a, f_b)"
-					"f_x := mul(f_x, f_c)"
-				"}"
-				"let y := add(mload(1), add(f_x, _1))"
-			"}"
-			"function f(a, b, c) -> x"
-			"{"
-				"x := add(a, b)"
-				"x := mul(x, c)"
-			"}"
-		"}", false)
-	);
-}
-
-BOOST_AUTO_TEST_CASE(pop_result)
-{
-	// This tests that `pop(r)` is removed.
-	BOOST_CHECK_EQUAL(
-		fullInline("{"
-			"function f(a) -> x { let r := mul(a, a) x := add(r, r) }"
-			"pop(add(f(7), 2))"
-		"}", false),
-		format("{"
-			"{"
-				"let _1 := 2 "
-				"let f_a := 7 "
-				"let f_x "
-				"{"
-					"let f_r := mul(f_a, f_a) "
-					"f_x := add(f_r, f_r)"
-				"}"
-				"{"
-				"}"
-			"}"
-			"function f(a) -> x"
-			"{"
-				"let r := mul(a, a) "
-				"x := add(r, r)"
-			"}"
-		"}", false)
-	);
-}
-
-BOOST_AUTO_TEST_CASE(inside_condition)
-{
-	// This tests that breaking the expression inside the condition works properly.
-	BOOST_CHECK_EQUAL(
-		fullInline("{"
-			"if gt(f(mload(1)), mload(0)) {"
-				"sstore(0, 2)"
-			"}"
-			"function f(a) -> r {"
-				"a := mload(a)"
-				"r := add(a, calldatasize())"
-			"}"
-		"}", false),
-		format("{"
-			"{"
-				"let _1 := mload(0)"
-				"let f_a := mload(1)"
-				"let f_r"
-				"{"
-					"f_a := mload(f_a)"
-					"f_r := add(f_a, calldatasize())"
-				"}"
-				"if gt(f_r, _1)"
-				"{"
-					"sstore(0, 2)"
-				"}"
-			"}"
-			"function f(a) -> r"
-			"{"
-				"a := mload(a)"
-				"r := add(a, calldatasize())"
-			"}"
-		"}", false)
-	);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/libjulia/YulOptimizerTest.cpp b/test/libjulia/YulOptimizerTest.cpp
index 878f1297..9f028bcd 100644
--- a/test/libjulia/YulOptimizerTest.cpp
+++ b/test/libjulia/YulOptimizerTest.cpp
@@ -28,6 +28,7 @@
 #include <libjulia/optimiser/FunctionGrouper.h>
 #include <libjulia/optimiser/FunctionHoister.h>
 #include <libjulia/optimiser/ExpressionInliner.h>
+#include <libjulia/optimiser/FullInliner.h>
 
 #include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/inlineasm/AsmPrinter.h>
@@ -113,6 +114,13 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 		disambiguate();
 		ExpressionInliner(*m_ast).run();
 	}
+	else if (m_optimizerStep == "fullInliner")
+	{
+		disambiguate();
+		(FunctionHoister{})(*m_ast);
+		(FunctionGrouper{})(*m_ast);
+		FullInliner(*m_ast).run();
+	}
 	else
 	{
 		FormattedScope(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Invalid optimizer step: " << m_optimizerStep << endl;
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/inside_condition.yul b/test/libjulia/yulOptimizerTests/fullInliner/inside_condition.yul
new file mode 100644
index 00000000..ae25e9a3
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/inside_condition.yul
@@ -0,0 +1,32 @@
+// This tests that breaking the expression inside the condition works properly.
+{
+	if gt(f(mload(1)), mload(0)) {
+		sstore(0, 2)
+	}
+	function f(a) -> r {
+		a := mload(a)
+		r := add(a, calldatasize())
+	}
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let _1 := mload(0)
+//         let f_a := mload(1)
+//         let f_r
+//         {
+//             f_a := mload(f_a)
+//             f_r := add(f_a, calldatasize())
+//         }
+//         if gt(f_r, _1)
+//         {
+//             sstore(0, 2)
+//         }
+//     }
+//     function f(a) -> r
+//     {
+//         a := mload(a)
+//         r := add(a, calldatasize())
+//     }
+// }
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/move_up_rightwards_argument.yul b/test/libjulia/yulOptimizerTests/fullInliner/move_up_rightwards_argument.yul
new file mode 100644
index 00000000..e1def585
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/move_up_rightwards_argument.yul
@@ -0,0 +1,28 @@
+{
+	function f(a, b, c) -> x {
+		x := add(a, b)
+		x := mul(x, c)
+	}
+	let y := add(mload(1), add(f(mload(2), mload(3), mload(4)), mload(5)))
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let _1 := mload(5)
+//         let f_c := mload(4)
+//         let f_b := mload(3)
+//         let f_a := mload(2)
+//         let f_x
+//         {
+//             f_x := add(f_a, f_b)
+//             f_x := mul(f_x, f_c)
+//         }
+//         let y := add(mload(1), add(f_x, _1))
+//     }
+//     function f(a, b, c) -> x
+//     {
+//         x := add(a, b)
+//         x := mul(x, c)
+//     }
+// }
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/multi_fun.yul b/test/libjulia/yulOptimizerTests/fullInliner/multi_fun.yul
new file mode 100644
index 00000000..94bbe5dc
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/multi_fun.yul
@@ -0,0 +1,40 @@
+{
+	function f(a) -> x { x := add(a, a) }
+	function g(b, c) -> y { y := mul(mload(c), f(b)) }
+	let y := g(f(3), 7)
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let g_c := 7
+//         let f_a_1 := 3
+//         let f_x_1
+//         {
+//             f_x_1 := add(f_a_1, f_a_1)
+//         }
+//         let g_y
+//         {
+//             let g_f_a := f_x_1
+//             let g_f_x
+//             {
+//                 g_f_x := add(g_f_a, g_f_a)
+//             }
+//             g_y := mul(mload(g_c), g_f_x)
+//         }
+//         let y_1 := g_y
+//     }
+//     function f(a) -> x
+//     {
+//         x := add(a, a)
+//     }
+//     function g(b, c) -> y
+//     {
+//         let f_a := b
+//         let f_x
+//         {
+//             f_x := add(f_a, f_a)
+//         }
+//         y := mul(mload(c), f_x)
+//     }
+// }
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/multi_return.yul b/test/libjulia/yulOptimizerTests/fullInliner/multi_return.yul
new file mode 100644
index 00000000..f3c5b0ee
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/multi_return.yul
@@ -0,0 +1,21 @@
+// The full inliner currently does not work with
+// functions returning multiple values.
+{
+	function f(a) -> x, y {
+		x := mul(a, a)
+		y := add(a, x)
+	}
+	let a, b := f(mload(0))
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let a_1, b := f(mload(0))
+//     }
+//     function f(a) -> x, y
+//     {
+//         x := mul(a, a)
+//         y := add(a, x)
+//     }
+// }
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/no_return.yul b/test/libjulia/yulOptimizerTests/fullInliner/no_return.yul
new file mode 100644
index 00000000..53fe3527
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/no_return.yul
@@ -0,0 +1,22 @@
+{
+	function f(a) {
+		sstore(a, a)
+	}
+	f(mload(0))
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let f_a := mload(0)
+//         {
+//             sstore(f_a, f_a)
+//         }
+//         {
+//         }
+//     }
+//     function f(a)
+//     {
+//         sstore(a, a)
+//     }
+// }
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/pop_result.yul b/test/libjulia/yulOptimizerTests/fullInliner/pop_result.yul
new file mode 100644
index 00000000..3883c67c
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/pop_result.yul
@@ -0,0 +1,28 @@
+// This tests that `pop(r)` is removed.
+{
+	function f(a) -> x {
+		let r := mul(a, a)
+		x := add(r, r)
+	}
+	pop(add(f(7), 2))
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let _1 := 2
+//         let f_a := 7
+//         let f_x
+//         {
+//             let f_r := mul(f_a, f_a)
+//             f_x := add(f_r, f_r)
+//         }
+//         {
+//         }
+//     }
+//     function f(a) -> x
+//     {
+//         let r := mul(a, a)
+//         x := add(r, r)
+//     }
+// }
diff --git a/test/libjulia/yulOptimizerTests/fullInliner/simple.yul b/test/libjulia/yulOptimizerTests/fullInliner/simple.yul
new file mode 100644
index 00000000..dd1a4e0a
--- /dev/null
+++ b/test/libjulia/yulOptimizerTests/fullInliner/simple.yul
@@ -0,0 +1,26 @@
+{
+	function f(a) -> x {
+		let r := mul(a, a)
+		x := add(r, r)
+	}
+	let y := add(f(sload(mload(2))), mload(7))
+}
+// ----
+// fullInliner
+// {
+//     {
+//         let _1 := mload(7)
+//         let f_a := sload(mload(2))
+//         let f_x
+//         {
+//             let f_r := mul(f_a, f_a)
+//             f_x := add(f_r, f_r)
+//         }
+//         let y := add(f_x, _1)
+//     }
+//     function f(a) -> x
+//     {
+//         let r := mul(a, a)
+//         x := add(r, r)
+//     }
+// }