[DEMO] Compiler Optimization

kerboscript_tests/integration/blank.ks

@@ -0,0 +1 @@
+@lazyGlobal OFF.

kerboscript_tests/integration/branching/for.ks

@@ -0,0 +1,7 @@
+@lazyGlobal OFF.
+
+print("beginning").
+for item in a {
+    print("body").
+}
+print("trunk").

kerboscript_tests/integration/branching/from.ks

@@ -0,0 +1,10 @@
+@lazyGlobal OFF.
+
+print("beginning").
+from {local i is 0.}
+until i = 10
+step {set i to i + 1.}
+do {
+    print("body").
+}
+print("trunk").

kerboscript_tests/integration/branching/if.ks

@@ -0,0 +1,7 @@
+@lazyGlobal OFF.
+
+print("beginning").
+if (a) {
+    print("branch").
+}
+print("trunk").

kerboscript_tests/integration/branching/ifElse.ks

@@ -0,0 +1,10 @@
+@lazyGlobal OFF.
+
+print("beginning").
+if (a) {
+    print("branch").
+}
+else {
+    print("else").
+}
+print("trunk").

kerboscript_tests/integration/branching/ifElseIf.ks

@@ -0,0 +1,10 @@
+@lazyGlobal OFF.
+
+print("beginning").
+if (a) {
+    print("branch").
+}
+else if (b) {
+    print("elseIf").
+}
+print("trunk").

kerboscript_tests/integration/branching/ifElseIfElse.ks

@@ -0,0 +1,13 @@
+@lazyGlobal OFF.
+
+print("beginning").
+if (a) {
+    print("branch").
+}
+else if (b) {
+    print("elseIf").
+}
+else{
+    print("else").
+}
+print("trunk").

kerboscript_tests/integration/branching/until.ks

@@ -0,0 +1,7 @@
+@lazyGlobal OFF.
+
+print("beginning").
+until (a) {
+    print("body").
+}
+print("trunk").

kerboscript_tests/integration/codeMotion.ks

@@ -0,0 +1,19 @@
+@lazyGlobal OFF.
+
+randomseed("random", 0).
+local a is random("random").
+local b is a + 1.
+print(b).
+from {local i is 0.}
+until i = 4
+step {set i to i + 1.}
+do {
+  set b to a + 2.
+  print(i).
+}
+print(b).
+for j in range(0, 4) {
+  set b to a + 1.
+  print (j).
+}
+print(b).

kerboscript_tests/integration/commonExpressionElimination.ks

@@ -0,0 +1,22 @@
+@lazyGlobal OFF.
+
+randomseed("random", 0).
+local a is 1.
+local b is random("random").
+local d is random("random").
+
+global c is a + b.
+
+print c.
+print a + b.
+print a + b.
+{
+    print a + b.
+    global e is b + d.
+    print b + d.
+    print b + d.
+    local f is e.
+    print f.
+}
+print "Outside".
+print b + d.

kerboscript_tests/integration/constantPropagation.ks

@@ -0,0 +1,64 @@
+@lazyGlobal OFF.
+
+global a is 5.
+global _false is false.
+
+local b is 1.
+set b to 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
+
+local 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 @@
+local a is TRUE.
+local c is 3.
+local x is 2.
+local 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/Compilation/TypeInferencing.cs

@@ -0,0 +1,92 @@
+using System;
+using NUnit.Framework;
+using kOS.Safe.Compilation;
+using kOS.Safe.Compilation.IR;
+using kOS.Safe.Encapsulation;
+using kOS.Safe.Test.Execution;
+using kOS.Safe.Utilities;
+
+namespace kOS.Safe.Test.Compilation
+{
+
+    [SetUpFixture]
+    public class StaticSetup
+    {
+        [SetUp]
+        public void Setup()
+        {
+            SafeHouse.Init(new Config(), new VersionInfo(0, 0, 0, 0), "", false, "./");
+            SafeHouse.Logger = new NoopLogger();
+
+            try
+            {
+                AssemblyWalkAttribute.Walk();
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e);
+                Console.WriteLine(e.StackTrace);
+                throw;
+            }
+        }
+    }
+
+    [TestFixture]
+    public class TypeInferencing
+    {
+        [Test]
+        public void StructureSuffixTest()
+        {
+            // Tests that the bare minimum works
+            Type structureType = typeof(Encapsulation.Structure);
+            Type result = TypeInferencer.GetTypeForSuffix(structureType, "TOSTRING");
+            Assert.AreEqual(typeof(StringValue), result);
+
+            Type integerType = typeof(ScalarIntValue);
+            result = TypeInferencer.GetTypeForSuffix(integerType, "istype");
+            Assert.AreEqual(typeof(BooleanValue), result);
+        }
+
+        [Test]
+        public void ListSuffixTest()
+        {
+            // Test that lists and enumerables work
+            Type listType = typeof(ListValue);
+            Type result = TypeInferencer.GetTypeForSuffix(listType, "ITERATOR");
+            Assert.AreEqual(typeof(Enumerator), result);
+
+            result = TypeInferencer.GetTypeForSuffix(listType, "COPY");
+            Assert.AreEqual(typeof(ListValue), result);
+
+            result = TypeInferencer.GetTypeForIndex(listType);
+            Assert.AreEqual(typeof(Encapsulation.Structure), result);
+
+            result = TypeInferencer.GetTypeForSuffix(listType, "CLEAR");
+            Assert.AreEqual(null, result);
+
+            // Test an abstract generic type
+            listType = typeof(EnumerableValue<Encapsulation.Structure, System.Collections.Generic.IEnumerable<Encapsulation.Structure>>);
+            result = TypeInferencer.GetTypeForSuffix(listType, "ITERATOR");
+            Assert.AreEqual(typeof(Enumerator), result);
+        }
+
+        [Test]
+        public void TestInstructionInferencing()
+        {
+            InterimConstantValue a = new InterimConstantValue(ScalarIntValue.One, 0, 0);
+            InterimConstantValue b = new InterimConstantValue(ScalarIntValue.Two, 0, 0);
+            IRBinaryOp add = new IRBinaryOp(null, new OpcodeMathAdd(), a, b);
+
+            Assert.AreEqual(typeof(ScalarValue), add.Type);
+
+            IRCall call = new IRCall(null, new OpcodeCall("sin"), true, b);
+            Assert.IsTrue(typeof(ScalarValue).IsAssignableFrom(call.Type));
+
+            IRCall print = new IRCall(null, new OpcodeCall("print"), true, a);
+            Assert.AreEqual(null, print.Type);
+
+            IRCall userCall = new IRCall(null, new OpcodeCall("$test*"), true, a, b);
+            Assert.AreEqual(typeof(Encapsulation.Structure), userCall.Type);
+        }
+    }
+}