[DEMO] Compiler Optimization

kerboscript_tests/integration/constantPropagation.ks

@@ -0,0 +1,63 @@
+@lazyGlobal OFF.
+
+global a is 5.
+global _false is false.
+
+local b is 2.
+local c is 4.
+local d is 7.
+local h is false.
+
+print("test").  // The assignments should happen after this line.
+
+print(b+c).     // 6
+print(h).       // False
+
+global function func {
+    print(b+c). // 6
+    print(b+d). // 9
+    print(b+a). // 7
+    set h to true.
+}
+
+func().
+
+{
+    local i is 10.
+    print(i).   // 10
+    print(i+c). // 14
+}
+
+print(h).   // True
+
+set h to false.
+
+print(h).   // False
+
+lock e to a + b.
+
+print(e).   // 7
+set b to 1.
+print(e).   // 6
+
+lock g to c + d.
+print(g).   // 11
+set d to 5.
+print(g).   // 9
+
+when _false then {
+    set c to 10.
+}
+
+print(b+c). // 5
+
+set b to 1.
+set b to b + d.
+
+print(b).   // 6
+
+until b = 1 {
+    set b to b - 1.
+}
+
+print(b).   // 1

kerboscript_tests/integration/operators.ks

@@ -18,3 +18,8 @@ print(1 = 1).
 print(1 <> 2).
 print(true and true).
 print(true or false).
+print("A" + "b").
+print(a * 0).
+print(a ^ 0).
+print(arcTan2(0,1)).
+print(abs(-1)).

kerboscript_tests/integration/operators_invalid.ks

@@ -0,0 +1,21 @@
+
+set a to 0.
+
+print(+ 1).
+print(- (-1)).
+print(not false).
+print(defined a).
+
+print(1 + 2).
+print(2 * 3).
+print(4 / 2).
+print(3 ^ 2).
+print(2 > 1).
+print(2 >= 1).
+print(1 < 2).
+print(1 <= 2).
+print(1 = 1).
+print(1 <> 2).
+print(true and true).
+print(true or false).
+print(1 + false).

kerboscript_tests/integration/peepholeOptimizations.ks

@@ -0,0 +1,51 @@
+parameter a is TRUE.
+parameter c is 3.
+parameter x is 2.
+parameter z is 5.
+
+print("test":typename()).
+// v() is unavailable in unit testing.
+//local v1 is v(1,2,3).
+//local v2 is v(3,4,5).
+// Multiplying scalars will work equally well.
+local v1 is 2.
+local v2 is 3.
+
+print(vectorDotProduct(v1,v2)). // =6
+print(vdot(v1,v2)).             // =6
+
+if not a {
+    print("Don't print this.").
+}
+
+if not (not a) {
+    print("Print this.").
+}
+
+print(c*x+c*z).     // = 21
+print(c*x+z*c).     // = 21
+print(x*c+c*z).     // = 21
+print(x*c+z*c).     // = 21
+
+print(-x+z).        // = 3
+print(x+-z).        // = -3
+
+print(x--z).        // = 7
+
+print(x^z/x).       // = 16
+print(z^4/z).       // = 125
+
+print(x^z*x).       // = 64
+print(z^4*z).       // = 3125
+
+print(x^z*x^c).     // = 256
+
+print(x^z/x^c).     // = 4
+
+print(z^3/z).       // = 25
+
+print(z*z*z).       // = 125
+
+print(z^3/z*z).     // = 125
+
+print(x^2*x^z/x*x^3).   // = 512

kerboscript_tests/integration/suffixReplacement.ks

@@ -0,0 +1,5 @@
+@CLOBBERBUILTINS OFF.
+set airspeed to 100. // Clobber the built-in so that this value is pulled after replacement.
+print(CONSTANT:g0).
+print(CONSTANT():pi).
+print(SHIP:airspeed).

src/kOS.Safe.Test/Execution/BaseIntegrationTest.cs

@@ -39,6 +39,7 @@ public abstract class BaseIntegrationTest
         private SafeSharedObjects shared;
         private Screen screen;
         private string baseDir;
+        protected virtual OptimizationLevel OptimizationLevel => OptimizationLevel.None;
 
         private string FindKerboscriptTests()
         {
@@ -86,12 +87,14 @@ protected void RunScript(string fileName)
                 IsCalledFromRun = false,
                 FuncManager = shared.FunctionManager,
                 BindManager = shared.BindingMgr,
-                AllowClobberBuiltins = SafeHouse.Config.AllowClobberBuiltIns
+                AllowClobberBuiltins = SafeHouse.Config.AllowClobberBuiltIns,
+                OptimizationLevel = OptimizationLevel
             });
             cpu.Boot();
 
             screen.ClearOutput();
 
+            cpu.PushArgumentStack(new KOSArgMarkerType());
             cpu.GetCurrentContext().AddParts(compiled);
         }
 

src/kOS.Safe.Test/Execution/OptimizationTest.cs

@@ -0,0 +1,210 @@
+using System;
+using NUnit.Framework;
+using kOS.Safe.Compilation;
+using kOS.Safe.Exceptions;
+
+namespace kOS.Safe.Test.Execution
+{
+    [TestFixture]
+    public class OptimizationTest : BaseIntegrationTest
+    {
+        protected override OptimizationLevel OptimizationLevel => OptimizationLevel.Minimal;
+
+        [Test]
+        public void TestBasic()
+        {
+            // Tests that the bare minimum works
+
+            RunScript("integration/basic.ks");
+            RunSingleStep();
+            AssertOutput(
+                "text"
+            );
+        }
+
+        [Test]
+        public void TestVars()
+        {
+            // Tests that basic variable assignment and reference works
+
+            RunScript("integration/vars.ks");
+            RunSingleStep();
+            AssertOutput(
+                "1",
+                "2",
+                "3"
+            );
+        }
+
+        [Test]
+        public void TestFunc()
+        {
+            // Tests that basic no-args function calls work
+
+            RunScript("integration/func.ks");
+            RunSingleStep();
+            AssertOutput(
+                "a"
+            );
+        }
+
+        [Test]
+        public void TestFuncArgs()
+        {
+            // Tests that explicit and default function parameters work
+
+            RunScript("integration/func_args.ks");
+            RunSingleStep();
+            AssertOutput(
+                "0",
+                "1",
+                "2",
+                "3"
+            );
+        }
+
+        [Test]
+        public void TestOperators()
+        {
+            // Test that all the basic operators work
+
+            RunScript("integration/operators.ks");
+            RunSingleStep();
+            AssertOutput(
+                "1",
+                "1",
+                "True",
+                "True",
+                "3",
+                "6",
+                "2",
+                "9",
+                "True",
+                "True",
+                "True",
+                "True",
+                "True",
+                "True",
+                "True",
+                "True",
+                "Ab",
+                "0",
+                "1",
+                "0",
+                "1"
+            );
+        }
+
+        [Test]
+        [ExpectedException(typeof(KOSCompileException))]
+        public void TestOperatorsException()
+        {
+            // Test that an invalid operation throws a compile error during constant folding
+            RunScript("integration/operators_invalid.ks");
+            RunSingleStep();
+        }
+
+        [Test]
+        public void TestLock()
+        {
+            // Test that locks in the same file works
+            RunScript("integration/lock.ks");
+            RunSingleStep();
+            AssertOutput(
+                "3",
+                "4",
+                "5"
+            );
+        }
+
+        [Test]
+        public void TestSuffixes()
+        {
+            // Test that various suffix and index combinations work for getting and setting
+            RunScript("integration/suffixes.ks");
+            RunSingleStep();
+            RunSingleStep();
+            AssertOutput(
+                "0",
+                "1",
+                "2",
+                "3",
+                "0",
+                "False"
+            );
+        }
+
+        [Test]
+        public void TestSuffixReplacement()
+        {
+            // Test that certain suffixes are replaced
+            RunScript("integration/suffixReplacement.ks");
+            RunSingleStep();
+            AssertOutput(
+                "9.80665",
+                "3.14159265358979",
+                "100"
+            );
+        }
+
+
+        [Test]
+        public void TestPeepholeOptimizations()
+        {
+            // Test that certain suffixes are replaced
+            RunScript("integration/peepholeOptimizations.ks");
+            RunSingleStep();
+            AssertOutput(
+                "String",
+                "6",
+                "6",
+                "Print this.",
+                "21",
+                "21",
+                "21",
+                "21",
+                "3",
+                "-3",
+                "7",
+                "16",
+                "125",
+                "64",
+                "3125",
+                "256",
+                "4",
+                "25",
+                "125",
+                "125",
+                "512"
+            );
+        }
+
+
+        [Test]
+        public void TestConstantPropagation()
+        {
+            // Test that local constant variables propagate
+            RunScript("integration/constantPropagation.ks");
+            RunSingleStep();
+            AssertOutput(
+                "test",
+                "6",
+                "False",
+                "6",
+                "9",
+                "7",
+                "10",
+                "14",
+                "True",
+                "False",
+                "7",
+                "6",
+                "11",
+                "9",
+                "5",
+                "6",
+                "1"
+            );
+        }
+    }
+}