add the possibility to check the IL in tests

src/FastExpressionCompiler.LightExpression/Expression.cs

@@ -50,6 +50,9 @@ public abstract class Expression
         /// <summary>Converts to Expression and outputs its as string</summary>
         public override string ToString() => ToExpression().ToString();
 
+        /// <summary>Reduces the Expression to simple ones</summary>
+        public virtual Expression Reduce() => this;
+
         public static ParameterExpression Parameter(Type type, string name = null) =>
             new ParameterExpression(type.IsByRef ? type.GetElementType() : type, name, type.IsByRef);
 
@@ -159,12 +162,27 @@ public static LambdaExpression Lambda(Expression body, params ParameterExpressio
         public static LambdaExpression Lambda(Type delegateType, Expression body, params ParameterExpression[] parameters) =>
             new LambdaExpression(delegateType, body, parameters);
 
+        public static UnaryExpression Not(Expression operand) =>
+            new UnaryExpression(ExpressionType.Not, operand, operand.Type);
+
+        public static TypeBinaryExpression TypeAs(Expression operand, Type type) =>
+            new TypeBinaryExpression(ExpressionType.TypeAs, operand, type);
+
+        public static UnaryExpression TypeIs(Expression operand, Type type) =>
+            new UnaryExpression(ExpressionType.TypeIs, operand, type);
+
         public static UnaryExpression Convert(Expression operand, Type targetType) =>
             new UnaryExpression(ExpressionType.Convert, operand, targetType);
 
         public static UnaryExpression Convert(Expression operand, Type targetType, MethodInfo method) =>
             new UnaryExpression(ExpressionType.Convert, operand, targetType, method);
 
+        public static UnaryExpression ConvertChecked(Expression operand, Type targetType) =>
+            new UnaryExpression(ExpressionType.ConvertChecked, operand, targetType);
+
+        public static UnaryExpression ConvertChecked(Expression operand, Type targetType, MethodInfo method) =>
+            new UnaryExpression(ExpressionType.ConvertChecked, operand, targetType, method);
+
         public static UnaryExpression PreIncrementAssign(Expression operand) =>
             new UnaryExpression(ExpressionType.PreIncrementAssign, operand, operand.Type);
 
@@ -568,6 +586,26 @@ protected BinaryExpression(ExpressionType nodeType, Expression left, Expression
         }
     }
 
+    public class TypeBinaryExpression : Expression
+    {
+        public override ExpressionType NodeType { get; }
+        public override Type Type { get; }
+
+        public Type TypeOperand { get; }
+
+        public readonly Expression Expression;
+
+        public override SysExpr ToExpression() => SysExpr.TypeIs(Expression.ToExpression(), TypeOperand);
+
+        internal TypeBinaryExpression(ExpressionType nodeType, Expression expression, Type typeOperand)
+        {
+            NodeType = nodeType;
+            Expression = expression;
+            Type = typeof(bool);
+            TypeOperand = typeOperand;
+        }
+    }
+
     public sealed class SimpleBinaryExpression : BinaryExpression
     {
         public override SysExpr ToExpression()

test/FastExpressionCompiler.IssueTests/FastExpressionCompiler.IssueTests.csproj

@@ -19,4 +19,10 @@
     <ProjectReference Include="..\..\src\FastExpressionCompiler\FastExpressionCompiler.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Reference Include="ILDebugging.Decoder">
+      <HintPath>..\libs\ILDebugging.Decoder.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+
 </Project>

test/FastExpressionCompiler.IssueTests/Issue146_bool_par_error.cs

@@ -0,0 +1,78 @@
+using System;
+using NUnit.Framework;
+
+#pragma warning disable IDE1006 // Naming Styles for linq2db
+#pragma warning disable 649 // Unaasigned fields
+
+#if LIGHT_EXPRESSION
+using static FastExpressionCompiler.LightExpression.Expression;
+namespace FastExpressionCompiler.LightExpression.UnitTests
+#else
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+namespace FastExpressionCompiler.UnitTests
+#endif
+{
+[TestFixture]
+    public class Issue146_bool_par_error
+    {
+
+        class MyObject
+        {
+            public bool a<b>(b i)
+            {
+                return Equals(i, false);
+            }
+        }
+
+
+        [Test]
+        public void Test1()
+        {
+            var objParam = Parameter(typeof(MyObject), "myObj");
+            var boolParam = Parameter(typeof(bool), "isSomething");
+            var myMethod = typeof(MyObject).GetMethod("a").MakeGenericMethod(typeof(bool));
+            var call = Call(objParam, myMethod, boolParam);
+
+            var lambda = Lambda<Func<MyObject, bool, bool>>(
+                call,
+                objParam,
+                boolParam);
+
+            var func = lambda.CompileFast();
+
+            var ret = func.Invoke(new MyObject(), false);
+
+            Assert.AreEqual(true, ret);
+        }
+
+
+        private class MyClass
+        {
+            public bool MyMethod<T>(bool i)
+            {
+                Console.WriteLine("Got " + i);
+
+                return Equals(i, false);
+            }
+        }
+
+        [Test]
+        public void Test2()
+        {
+            var objParam = Parameter(typeof(MyClass), "myObj");
+            var boolParam = Parameter(typeof(bool), "isSomething");
+            var myMethod = typeof(MyClass).GetMethod("MyMethod").MakeGenericMethod(typeof(object));
+            var call = Call(objParam, myMethod, boolParam);
+
+            var lambda = Lambda<Func<MyClass, bool, bool>>(
+                call,
+                objParam,
+                boolParam);
+
+            var func = lambda.CompileFast();
+
+            func.Invoke(new MyClass(), false);
+        }
+    }
+}

test/FastExpressionCompiler.IssueTests/Issue147_int_try_parse.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using NUnit.Framework;
+
+#pragma warning disable IDE1006 // Naming Styles for linq2db
+#pragma warning disable 649 // Unaasigned fields
+
+#if LIGHT_EXPRESSION
+using static FastExpressionCompiler.LightExpression.Expression;
+namespace FastExpressionCompiler.LightExpression.UnitTests
+#else
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+namespace FastExpressionCompiler.UnitTests
+#endif
+{
+[TestFixture]
+    public class Issue147_int_try_parse
+    {
+
+        class MyObject
+        {
+            public bool a<b>(b i)
+            {
+                return Equals(i, false);
+            }
+        }
+
+#if !LIGHT_EXPRESSION
+        [Test]
+        public void Test1()
+        {
+            var intValueParameter = Parameter(typeof(int), "intValue");
+
+            var tryParseMethod = typeof(int)
+                .GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .First(m => m.Name == "TryParse" && m.GetParameters().Length == 2);
+
+            var tryParseCall = Call(
+                tryParseMethod,
+                Constant("123", typeof(string)),
+                intValueParameter);
+
+            var parsedValueOrDefault = Condition(
+                tryParseCall,
+                intValueParameter,
+                Default(typeof(int)));
+
+            var conditionBlock = Block(new[] { intValueParameter }, parsedValueOrDefault);
+
+            var conditionLambda = Lambda<Func<int>>(conditionBlock);
+
+            var conditionFunc = conditionLambda.Compile();
+
+            var parsedValue = conditionFunc.Invoke();
+
+
+            var conditionFuncFast = conditionLambda.CompileFast();
+
+            var parsedValueFast = conditionFuncFast.Invoke();
+
+            Assert.AreEqual(parsedValue, parsedValueFast);
+        }
+#endif
+    }
+}

test/FastExpressionCompiler.IssueTests/Issue150_New_AttemptToReadProtectedMemory.cs

@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+#pragma warning disable 659
+
+#if LIGHT_EXPRESSION
+using static FastExpressionCompiler.LightExpression.Expression;
+namespace FastExpressionCompiler.LightExpression.UnitTests
+#else
+ using static System.Linq.Expressions.Expression;
+ namespace FastExpressionCompiler.UnitTests
+#endif
+{
+    using System;
+    using System.Linq;
+    using System.Reflection;
+
+    [TestFixture]
+    public class Issue150_New_AttemptToReadProtectedMemory
+    {
+        [Test]
+        public void Nested_Assignments_Should_Work()
+        {
+            // Builds:
+            // 
+            // dsosToPpssData =>
+            // {
+            //     var publicPropertyStruct_String = dsosToPpssData.Target;
+            //     string valueKey;
+            //     object value;
+            //     publicPropertyStruct_String.Value = ((valueKey = dsosToPpssData.Source.Keys.FirstOrDefault(key => key.MatchesKey("Value"))) != null)
+            //         ? ((value = dsosToPpssData.Source[valueKey]) != null) ? value.ToString() : null
+            //         : null;
+
+            //     return publicPropertyStruct_String;
+            // }
+
+            var mappingDataParameter = Parameter(
+                typeof(MappingData<Dictionary<string, int>, PublicPropertyStruct<string>>),
+                "dsosToPpssData");
+
+            var structVariable = Variable(typeof(PublicPropertyStruct<string>), "publicPropertyStruct_String");
+
+            var structVariableAssignment = Assign(structVariable, Property(mappingDataParameter, "Target"));
+
+            var sourceDictionary = Property(mappingDataParameter, "Source");
+            var nullString = Default(typeof(string));
+            var valueKeyVariable = Variable(typeof(string), "valueKey");
+
+            var linqFirstOrDefaultMethod = typeof(Enumerable)
+                .GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .First(m => m.Name == "FirstOrDefault" && m.GetParameters().Length == 2)
+                .MakeGenericMethod(typeof(string));
+
+            var dictionaryKeys = Property(sourceDictionary, "Keys");
+
+            var keyParameter = Parameter(typeof(string), "key");
+            var matchesKeyMethod = typeof(MyIssueExtensions).GetMethod("MatchesKey");
+            var matchesKeyCall = Call(matchesKeyMethod, keyParameter, Constant("Value"));
+            var matchesKeyLambda = Lambda<Func<string, bool>>(matchesKeyCall, keyParameter);
+
+            var firstOrDefaultKeyCall = Call(linqFirstOrDefaultMethod, dictionaryKeys, matchesKeyLambda);
+
+            var valueKeyAssignment = Assign(valueKeyVariable, firstOrDefaultKeyCall);
+            var valueKeyNotNull = NotEqual(valueKeyAssignment, nullString);
+
+            var valueVariable = Variable(typeof(object), "value");
+
+            var dictionaryIndexer = sourceDictionary.Type.GetProperties().First(p => p.GetIndexParameters().Length != 0);
+            var dictionaryIndexAccess = MakeIndex(sourceDictionary, dictionaryIndexer, new[] { valueKeyVariable });
+            var dictionaryValueAsObject = Convert(dictionaryIndexAccess, typeof(object));
+
+            var valueAssignment = Assign(valueVariable, dictionaryValueAsObject);
+            var valueNotNull = NotEqual(valueAssignment, Default(valueVariable.Type));
+
+            var objectToStringMethod = valueVariable.Type.GetMethod("ToString");
+            var valueToString = Call(valueVariable, objectToStringMethod);
+
+            var valueToStringOrNull = Condition(valueNotNull, valueToString, nullString);
+
+            var dictionaryEntryOrNull = Condition(valueKeyNotNull, valueToStringOrNull, nullString);
+
+            var structValueProperty = Property(structVariable, "Value");
+
+            var structValueAssignment = Assign(structValueProperty, dictionaryEntryOrNull);
+
+            var structPopulation = Block(
+                new[] { valueKeyVariable, valueVariable },
+                structValueAssignment);
+
+            var structMapping = Block(
+                new[] { structVariable },
+                structVariableAssignment,
+                structPopulation,
+                structVariable);
+
+            var populationLambda = Lambda<Func<MappingData<Dictionary<string, int>, PublicPropertyStruct<string>>, PublicPropertyStruct<string>>>(
+                structMapping,
+                mappingDataParameter);
+
+            var populationFunc = populationLambda.CompileFast();
+            populationFunc.Invoke(new MappingData<Dictionary<string, int>, PublicPropertyStruct<string>>
+            {
+                Source = new Dictionary<string, int> { ["Value"] = 123 },
+                Target = new PublicPropertyStruct<string>()
+            });
+        }
+
+        public class MappingData<TSource, TTarget>
+        {
+            public TSource Source { get; set; }
+
+            public TTarget Target { get; set; }
+        }
+
+        public struct PublicPropertyStruct<T>
+        {
+            public T Value { get; set; }
+        }
+    }
+
+    public static class MyIssueExtensions
+    {
+        public static bool MatchesKey(this string value, string other) => value == other;
+    }
+}

test/FastExpressionCompiler.IssueTests/Issue153_MinValueMethodNotSupported.cs

@@ -0,0 +1,26 @@
+using System;
+using NUnit.Framework;
+#pragma warning disable 659
+#if LIGHT_EXPRESSION
+using static FastExpressionCompiler.LightExpression.Expression;
+namespace FastExpressionCompiler.LightExpression.UnitTests
+#else
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+namespace FastExpressionCompiler.UnitTests
+#endif
+{
+    [TestFixture]
+    public class Issue153_MinValueMethodNotSupported
+    {
+        [Test]
+        public void Int_MinValue_Should_Work()
+        {
+            var minValueField = typeof(int).GetField("MinValue");
+            var minValue = Field(null, minValueField);
+            var minValueLambda = Lambda<Func<int>>(minValue);
+            var res = minValueLambda.CompileFast();
+            Assert.AreEqual(int.MinValue, res());
+        }
+    }
+}