simple Label & Goto support (dadhi#103)

* feature - helper to save to file

* fix dadhi#102 - introduce label and goto support

* feature - test for dadhi#100

* feature - tests for dadhi#78

* bugfix - fixes dadhi#78

* bugfix - remove save to assembly

* bugfix : expression save helper only for net46

* feature - include a editorconfig , fixes dadhi#97

* remove doubled test

* bugfix - nullable char scenario from linq2db

* optimize dictionary to keyvalue array

* optimize code

* label not found should throw

Author: jogibear9988

.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -364,6 +364,10 @@ private static object TryCompile(ref ClosureInfo closureInfo,
             else
                 return null;
 
+            if (closureInfo.LabelCount > 0)
+                closureInfo.Labels = new KeyValuePair<object, Label>[closureInfo.LabelCount];
+            closureInfo.LabelCount = 0;
+
             var closureType = closureInfo.ClosureType;
             var methodParamTypes = closureType == null ? paramTypes : GetClosureAndParamTypes(paramTypes, closureType);
 
@@ -476,6 +480,10 @@ private struct ClosureInfo
             // Helper to decide whether we are inside the block or not
             public BlockInfo CurrentBlock;
 
+            public int LabelCount;
+            // Dictionary for the used Labels in IL
+            public KeyValuePair<object, Label>[] Labels;
+
             // Populates info directly with provided closure object and constants.
             public ClosureInfo(bool isConstructed, object closure = null, object[] closureConstantExpressions = null)
             {
@@ -484,6 +492,8 @@ public ClosureInfo(bool isConstructed, object closure = null, object[] closureCo
                 NonPassedParameters = Tools.Empty<object>();
                 NestedLambdas = Tools.Empty<NestedLambdaInfo>();
                 CurrentBlock = BlockInfo.Empty;
+                Labels = null;
+                LabelCount = 0;
 
                 if (closure == null)
                 {
@@ -986,6 +996,17 @@ private static bool TryCollectBoundConstants(ref ClosureInfo closure,
                         ? TryCollectTryExprConstants(ref closure, (TryExpression)exprObj, paramExprs)
                         : TryCollectTryExprInfoConstants(ref closure, (TryExpressionInfo)exprObj, paramExprs);
 
+                case ExpressionType.Label:
+                    closure.LabelCount++;
+                    var defaultValueExpr = ((LabelExpression)exprObj).DefaultValue;
+                    return defaultValueExpr == null
+                           || TryCollectBoundConstants(ref closure, defaultValueExpr, defaultValueExpr.NodeType, paramExprs);
+
+                case ExpressionType.Goto:
+                    var gotoValueExpr = ((GotoExpression)exprObj).Value;
+                    return gotoValueExpr == null
+                           || TryCollectBoundConstants(ref closure, gotoValueExpr, gotoValueExpr.NodeType, paramExprs);
+
                 case ExpressionType.Default:
                     return true;
 
@@ -1273,7 +1294,7 @@ private static class EmittingVisitor
                 .DeclaredMethods.First(m => m.IsStatic && m.Name == "Equals");
 
             public static bool TryEmit(object exprObj, ExpressionType exprNodeType, Type exprType,
-                object[] paramExprs, ILGenerator il, ref ClosureInfo closure, ExpressionType parent, int byRefIndex = -1)
+                object[] paramExprs, ILGenerator il, ref ClosureInfo closure, ExpressionType parent,  int byRefIndex = -1)
             {
                 switch (exprNodeType)
                 {
@@ -1346,11 +1367,58 @@ public static bool TryEmit(object exprObj, ExpressionType exprNodeType, Type exp
                     case ExpressionType.Index:
                         return TryEmitIndex((IndexExpression)exprObj, exprType, paramExprs, il, ref closure);
 
+                    case ExpressionType.Goto:
+                        return TryEmitGoto((GotoExpression)exprObj, exprType, paramExprs, il, ref closure);
+
+                    case ExpressionType.Label:
+                        return TryEmitLabel((LabelExpression)exprObj, exprType, paramExprs, il, ref closure);
+
                     default:
                         return false;
                 }
             }
 
+            private static bool TryEmitLabel(LabelExpression exprObj, Type elemType,
+                object[] paramExprs, ILGenerator il, ref ClosureInfo closure)
+            {
+                var lbl = closure.Labels.FirstOrDefault(x => x.Key == exprObj.Target);
+                if (lbl.Key != exprObj.Target)
+                {
+                    lbl = new KeyValuePair<object, Label>(exprObj.Target, il.DefineLabel());
+                    closure.Labels[closure.LabelCount++] = lbl;
+                }
+                il.MarkLabel(lbl.Value);
+
+                if (exprObj.DefaultValue != null && !TryEmit(exprObj.DefaultValue, exprObj.DefaultValue.NodeType, exprObj.DefaultValue.Type, paramExprs, il, ref closure, ExpressionType.Label))
+                    return false;
+                return true;
+            }
+
+            private static bool TryEmitGoto(GotoExpression exprObj, Type elemType,
+                object[] paramExprs, ILGenerator il, ref ClosureInfo closure) //todo : GotoExpression.Value 
+            {
+                if (closure.Labels == null)
+                    throw new InvalidOperationException("cannot jump, no labels found");
+
+                var lbl = closure.Labels.FirstOrDefault(x => x.Key == exprObj.Target);
+                if (lbl.Key != exprObj.Target)
+                {
+                    if(closure.Labels.Length == closure.LabelCount - 1)
+                        throw new InvalidOperationException("Cannot jump, not all labels found");
+
+                    lbl = new KeyValuePair<object, Label>(exprObj.Target, il.DefineLabel());
+                    closure.Labels[closure.LabelCount++] = lbl;
+                }
+
+                if (exprObj.Kind == GotoExpressionKind.Goto)
+                {
+                    il.Emit(OpCodes.Br, lbl.Value);
+                    return true;
+                }
+
+                return false;
+            }
+
             private static bool TryEmitIndex(IndexExpression exprObj, Type elemType,
                 object[] paramExprs, ILGenerator il, ref ClosureInfo closure)
             {
@@ -1815,6 +1883,13 @@ private static bool TryEmitConvert(object exprObj, Type targetType,
 
                 if (targetType == typeof(object))
                 {
+                    var nullableType = Nullable.GetUnderlyingType(sourceType);
+                    if (nullableType != null)
+                    {
+                        il.Emit(OpCodes.Newobj, sourceType.GetTypeInfo().DeclaredConstructors.First());
+                        il.Emit(OpCodes.Box, sourceType);
+                        return true;
+                    }
                     // for value type to object, just box a value, otherwise do nothing - everything is object anyway
                     if (sourceType.GetTypeInfo().IsValueType)
                         il.Emit(OpCodes.Box, sourceType);

test/FastExpressionCompiler.IssueTests/ExpressionSaveHelper.cs

@@ -0,0 +1,25 @@
+using System;
+using System.IO;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FastExpressionCompiler.IssueTests
+{
+#if NET46
+    public static class ExpressionSaveHelper
+    {
+        public static void SaveToAssembly<T>(this Expression<T> lambda, string file)
+        {
+            AssemblyName assemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(file));
+            AssemblyBuilder dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save, Path.GetDirectoryName(file));
+            var dynamicModule = dynamicAssembly.DefineDynamicModule(assemblyName + "_module", assemblyName + ".dll");
+            var dynamicType = dynamicModule.DefineType(assemblyName + "_type");
+
+            lambda.CompileToMethod(dynamicType.DefineMethod(assemblyName.Name+"_method", MethodAttributes.Public | MethodAttributes.Static));
+            dynamicType.CreateType();
+            dynamicAssembly.Save(Path.GetFileName(file));
+        }
+    }
+#endif
+}

test/FastExpressionCompiler.IssueTests/Issue100_ExpressionInfo_wrong_return_type.cs

@@ -0,0 +1,21 @@
+using NUnit.Framework;
+
+namespace FastExpressionCompiler.IssueTests
+{
+    class Issue100_ExpressionInfo_wrong_return_type
+    {
+        delegate void ActionRef<T>(ref T a1);
+
+        [Test, Ignore("needs fix")]
+        public void RefAssignExpInfo()
+        {
+            var objRef = FastExpressionCompiler.ExpressionInfo.Parameter(typeof(double).MakeByRefType());
+            var lambda = FastExpressionCompiler.ExpressionInfo.Lambda<ActionRef<double>>(FastExpressionCompiler.ExpressionInfo.Assign(objRef, FastExpressionCompiler.ExpressionInfo.Add(objRef, FastExpressionCompiler.ExpressionInfo.Constant((double)3.0))), objRef);
+
+            var compiledB = lambda.CompileFast(true);
+            var exampleB = 5.0;
+            compiledB(ref exampleB);
+            Assert.AreEqual(8.0, exampleB);
+        }
+    }
+}

test/FastExpressionCompiler.IssueTests/Issue102_Label_and_Goto_Expression.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Linq.Expressions;
+using NUnit.Framework;
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+
+namespace FastExpressionCompiler.IssueTests
+{
+    class Issue102_Label_and_Goto_Expression
+    {
+        [Test]
+        public void BlockWithGotoIsSupported()
+        {
+            LabelTarget returnTarget = Expression.Label("aaa");
+
+            BlockExpression blockExpr =
+                Expression.Block(
+                    Expression.Call(typeof(Console).GetMethod("WriteLine", new[] {typeof(string)}),
+                        Expression.Constant("GoTo")),
+                    Expression.Goto(returnTarget),
+                    Expression.Call(typeof(Console).GetMethod("WriteLine", new[] {typeof(string)}),
+                        Expression.Constant("Other Work")),
+                    Expression.Label(returnTarget),
+                    Expression.Constant(7)
+                );
+
+            var lambda = Expression.Lambda<Func<int>>(blockExpr);
+            var fastCompiled = lambda.CompileFast<Func<int>>(true);
+            Assert.NotNull(fastCompiled);
+        }
+
+        [Test]
+        public void UnkownLabelShouldThrow()
+        {
+            var lambda = Expression.Lambda(
+                Expression.Return(Expression.Label(), Expression.Constant(1)));
+
+            Assert.Throws<InvalidOperationException>(() => lambda.Compile());
+            Assert.Throws<InvalidOperationException>(() => lambda.CompileFast(true));
+        }
+    }
+}

test/FastExpressionCompiler.IssueTests/Issue78_blocks_with_constant_return.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using NUnit.Framework;
+using static System.Linq.Expressions.Expression;
+
+namespace FastExpressionCompiler.IssueTests
+{
+    class Issue78_blocks_with_constant_return
+    {
+        [Test]
+        public void BlockWithConstanReturnIsSupported()
+        {
+            var ret = Block(Label(Label(typeof(int)), Constant(7)));
+            var lambda = Lambda<Func<int>>(ret);
+            var compiled = lambda.Compile();
+            var value1 = compiled();
+            Assert.AreEqual(7, value1);
+            var fastCompiled = lambda.CompileFast<Func<int>>(true);
+            Assert.IsNotNull(fastCompiled);
+            Assert.AreEqual(7, fastCompiled());
+        }
+
+        [Test]
+        public void ConstantReturnIsSupported()
+        {
+            var lambda = Lambda<Func<int>>(Label(Label(typeof(int)), Constant(7)));
+            var compiled = lambda.Compile();
+            var value1 = compiled();
+            Assert.AreEqual(7, value1);
+            var fastCompiled = lambda.CompileFast<Func<int>>(true);
+            Assert.IsNotNull(fastCompiled);
+            Assert.AreEqual(7, fastCompiled());
+        }
+
+        [Test]
+        public void ConstantReturnIsSupported2()
+        {
+            var varr = Variable(typeof(int), "xxx");
+            var assign = Assign(varr, Constant(7));
+            var lambda = Lambda<Func<int>>(Block(new List<ParameterExpression> { varr }, assign, Label(Label(typeof(int)), varr)));
+            var compiled = lambda.Compile();
+            var value1 = compiled();
+            Assert.AreEqual(7, value1);
+            var fastCompiled = lambda.CompileFast<Func<int>>(true);
+            Assert.IsNotNull(fastCompiled);
+            Assert.AreEqual(7, fastCompiled());
+        }
+    }
+}

test/FastExpressionCompiler.IssueTests/Issue83_linq2db.cs

@@ -281,7 +281,6 @@ public void Enum_to_enum_conversion()
         }
 
         [Test]
-        [Ignore("Test kills test runner process")]
         public void AccessViolationException_on_nullable_char_convert_to_object()
         {
             var body = Expression.Convert(

test/FastExpressionCompiler.IssueTests/Issue91_Issue95_Tests.cs

@@ -27,18 +27,6 @@ public void RefAssign()
             Assert.AreEqual(8.0, exampleB);
         }
 
-        [Test, Ignore("needs fix")]
-        public void RefAssignExpInfo()
-        {
-            var objRef = FastExpressionCompiler.ExpressionInfo.Parameter(typeof(double).MakeByRefType());
-            var lambda = FastExpressionCompiler.ExpressionInfo.Lambda<ActionRef<double>>(FastExpressionCompiler.ExpressionInfo.Assign(objRef, FastExpressionCompiler.ExpressionInfo.Add(objRef, FastExpressionCompiler.ExpressionInfo.Constant((double)3.0))), objRef);
-
-            var compiledB = lambda.CompileFast(true);
-            var exampleB = 5.0;
-            compiledB(ref exampleB);
-            Assert.AreEqual(8.0, exampleB);
-        }
-
         [Test]
         public void NullComparisonTest()
         {

test/FastExpressionCompiler.UnitTests/ConditionalOperatorsTests.cs

@@ -131,7 +131,7 @@ public void Ternarary_operator_with_logical_op()
             Assert.AreEqual(string.Concat(s, "ccc"), dlg());
         }
 
-        [Test]
+        [Test, Ignore("Return & Label are now supported")]
         public void CompileFast_should_return_null_when_option_is_set_and_expression_type_is_not_supported()
         {
             Assert.IsNull(Lambda(