Merge branch 'master' of github.com:vddCore/EVIL

Author: vddCore

VirtualMachine/EVIL.Ceres/EVIL.Ceres.csproj

@@ -8,7 +8,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <EnableUnsafeBinaryFormatterSerialization>true</EnableUnsafeBinaryFormatterSerialization>
 
-    <Version>9.2.0</Version>
+    <Version>9.2.1</Version>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>

VirtualMachine/EVIL.Ceres/ExecutionEngine/Diagnostics/Chunk.cs

@@ -355,6 +355,16 @@ public static Chunk Deserialize(Stream stream, out byte version, out long timest
 
     public Chunk Clone()
     {
+        var contexts = new Dictionary<string, ClosureContext>();
+        foreach (var kvp in _closureContexts)
+        {
+            contexts[kvp.Key] = new ClosureContext(kvp.Value.EnclosedFunctionName);
+            foreach (var kvp2 in kvp.Value.Values)
+            {
+                contexts[kvp.Key].Values[kvp2.Key] = kvp2.Value;
+            }
+        }
+        
         var clone = new Chunk(
             Name,
             _code.ToArray(),
@@ -369,7 +379,7 @@ public Chunk Clone()
             IsSelfAware = IsSelfAware,
             _subChunks = new(_subChunks),
             _closures = new(_closures),
-            _closureContexts = new(_closureContexts),
+            _closureContexts = contexts,
             _labels = new(_labels),
             _attributes = new(_attributes),
             _parameterInitializers = new(_parameterInitializers),

VirtualMachine/EVIL.Ceres/ExecutionEngine/ExecutionUnit.cs

@@ -7,6 +7,7 @@ namespace EVIL.Ceres.ExecutionEngine;
 using EVIL.Ceres.ExecutionEngine.Collections;
 using EVIL.Ceres.ExecutionEngine.Concurrency;
 using EVIL.Ceres.ExecutionEngine.Diagnostics;
+using EVIL.Ceres.ExecutionEngine.Marshaling;
 using EVIL.Ceres.ExecutionEngine.TypeSystem;
 using EVIL.CommonTypes.TypeSystem;
 
@@ -1087,7 +1088,18 @@ public void Step()
                     }
                     else
                     {
-                        PushValue(targetFrame.Locals![closureInfo.EnclosedId]);
+                        if (frame.Chunk.ClosureContexts.ContainsKey(closureInfo.EnclosedFunctionName))
+                        {
+                            PushValue(
+                                frame.Chunk.ClosureContexts[
+                                    closureInfo.EnclosedFunctionName
+                                ].Values[closureInfo.EnclosedId]
+                            );
+                        }
+                        else
+                        {
+                            PushValue(targetFrame.Locals![closureInfo.EnclosedId]);
+                        }
                     }
                 }
                 else
@@ -1190,7 +1202,16 @@ public void Step()
                 }
                 else
                 {
-                    PushValue(a.NativeObject!.GetType().FullName!);
+                    var obj = a.NativeObject!;
+
+                    if (obj is INativeTypeProvider nativeTypeProvider)
+                    {
+                        PushValue(nativeTypeProvider.ProvideType());
+                    }
+                    else
+                    {
+                        PushValue(a.NativeObject!.GetType().FullName!);
+                    }
                 }
 
                 break;
@@ -1449,7 +1470,7 @@ public void Step()
 
                 if (value == DynamicValue.Nil)
                 {
-                    value = new Table();
+                    value = new Table();                   
                     c.SetEntry(a, value);
                 }
 

VirtualMachine/EVIL.Ceres/ExecutionEngine/Marshaling/INativeTypeProvider.cs

@@ -0,0 +1,6 @@
+namespace EVIL.Ceres.ExecutionEngine.Marshaling;
+
+public interface INativeTypeProvider
+{
+    string ProvideType();
+}

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/NativeTypeProviderObject.cs

@@ -0,0 +1,9 @@
+namespace EVIL.Ceres.LanguageTests;
+
+using EVIL.Ceres.ExecutionEngine.Marshaling;
+
+public class NativeTypeProviderObject : INativeTypeProvider
+{
+    public string ProvideType()
+        => "SomeNativeTypeLol";
+}

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/TestRunner.cs

@@ -144,6 +144,8 @@ private async Task<int> Execute(TestSet testSet)
             VM.Global.Set("__new_dummy_object_2", new(
                 (_, _) => DynamicValue.FromObject(new DummyNativeClass()))
             );
+            VM.Global.Set("__new_native_type_provider_object", new (
+                (_, _) => DynamicValue.FromObject(new NativeTypeProviderObject())));
 
             VM.Global.Set("__throw_test", new(
                 (fiber, args) => fiber.ThrowFromNative(args[0]))

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/000_regression.vil

@@ -1,55 +1,43 @@
-fn delay(ms) { 
-  val end = time.stamp.ms + ms;
-  while(time.stamp.ms < end){}
+#[test]
+fn for_loop_table_fill {
+  val t = {};
 
-  ret 2.137;
+  for (rw val i = 0; i < 4; i++) {
+    t[i] = i;
+  }
+
+  assert.equal(t[0], 0);
+  assert.equal(t[1], 1);
+  assert.equal(t[2], 2);
+  assert.equal(t[3], 3);
 }
 
+
 #[test]
-fn yield_zombie {
-  rw val outer_arg = nil;
-  rw val zombified = false;
+fn for_loop_closure_capture {
+  val funcs = {};
 
-  loc fn dies_and_rises(rw arg) {
-    rw val zombified_2 = false;
-    
-    loc fn dies_and_rises_2 {
-      if (!zombified_2) {
-        arg = 12;
-        zombified_2 = true;
-        yield<delay>(10);
-        yield<dies_and_rises_2>();
-        
-        throw arg;
-      }
-    }
+  for (rw val i = 0; i < 3; i++) {
+    funcs[i] = fn -> i;
+  }
 
-    if (!zombified) {
-      zombified = true;
-      yield<delay>(10);
-      yield<dies_and_rises>();
-      
-      try {
-        yield<dies_and_rises_2>();
-      } catch (e) {
-        outer_arg = e;
-      }
-    }
+  assert.equal(funcs[0](), 0);
+  assert.equal(funcs[1](), 1);
+  assert.equal(funcs[2](), 2);
+}
 
-    ret "undead";
-  }
+fn delay(ms) { 
+  val end = time.stamp.ms + ms;
+  while(time.stamp.ms < end){}
 
-  zombified = false;
-  val result = yield<dies_and_rises>();
-  assert.equal(outer_arg, 12);
-  assert.equal(result, "undead");
+  ret 2.137;
 }
 
 #[test]
 fn tonum_indexing {
   val data = { a: { b: { c: "1", d: "2", e: "3", f: "4" } } };
   val x = $data.a.b.c * $data.a.b.d;
-  
+
   assert.equal(x, 2);
 }
 

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/008_for_loop.vil

@@ -75,4 +75,49 @@ fn for_multiple_statements {
 
   assert.equal(i, 10);
   assert.equal(j, 20);
+}
+
+#[test]
+fn for_loop_mutates_limit {
+  rw val i, limit = 5;
+
+  for (i = 0; i < limit; i++) {
+    if (i == 2) limit = 10;
+  }
+
+  assert.equal(i, 10);
+}
+
+#[test]
+fn for_loop_nested_skip_break {
+  rw val count = 0;
+
+  for (rw val i = 0; i < 5; i++) {
+    for (rw val j = 0; j < 5; j++) {
+      if (j == 2) skip;
+      if (j == 4) break;
+      count += 1;
+    }
+  }
+
+  /* j=0,1,3; i=0..4 → 3 * 5 = 15 */
+  assert.equal(count, 15);
+}
+
+#[test]
+fn for_skip_increment {
+  rw val i = 0, count = 0;
+
+  for (i; i < 10; i) {
+    if (i % 2 == 0) {
+      i++;
+      skip;
+    }
+
+    count++;
+    i++;
+  }
+
+  assert.equal(count, 5);
+  assert.equal(i, 10);
 }

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/012_type.vil

@@ -127,15 +127,30 @@ fn value_is_native_type_via_interpolated_string {
 }
 
 #[test]
-fn value_native_type_get_when_native_object() {
+fn value_native_type_get_when_native_object {
   val testval = __new_dummy_object();
   val type = typeof!(testval);
 
   assert.equal(type, "EVIL.Ceres.LanguageTests.DummyNativeClass");
 }
 
 #[test]
-fn value_native_type_get_when_not_native_object() {
+fn value_native_type_get_when_not_native_object {
   val type = typeof!(21.37);
   assert.equal(type, nil);
+}
+
+#[test]
+fn value_native_type_get_when_type_provider {
+  val testval = __new_native_type_provider_object();
+  val type = typeof!(testval);
+  
+  assert.equal(type, "SomeNativeTypeLol");
+}
+
+#[test]
+fn value_is_native_type_with_provider {
+  val testval = __new_native_type_provider_object();
+  
+  assert(testval is NativeObject "SomeNativeTypeLol");
 }

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/019_closures.vil

@@ -177,7 +177,7 @@ fn many_subchunks_capture_same_local_no_change {
 }
 
 #[test]
-fn many_subchunks_capture_same_local_after_change {
+fn many_subchunks_capture_local_value_after_change {
   rw val local_a = 11;
   val f1 = fn(x) -> local_a + x;
 
@@ -192,7 +192,7 @@ fn many_subchunks_capture_same_local_after_change {
 
   val result = f1(2) + f2(4) + f3(5) + f4(4);
 
-  assert.equal(result, 47);
+  assert.equal(result, 59);
 }
 
 fn invoke_func_out_of_scope(f) -> f();