TypeEqual expression is not supported

It was supported before, but the implementation is incorrect,
so I changed it to fallback to System Compile (and I think
this expression type is quite rare).

Author: exyi

src/FastExpressionCompiler.LightExpression/Expression.cs

@@ -2389,7 +2389,14 @@ internal TypeBinaryExpression(ExpressionType nodeType, Expression expression, Ty
         protected internal override Expression Accept(ExpressionVisitor visitor) => visitor.VisitTypeBinary(this);
 #endif
         internal override SysExpr CreateSysExpression(ref LiveCountArray<LightAndSysExpr> exprsConverted) =>
-            SysExpr.TypeIs(Expression.ToExpression(ref exprsConverted), TypeOperand);
+            NodeType switch {
+                ExpressionType.TypeIs =>
+                    SysExpr.TypeIs(Expression.ToExpression(ref exprsConverted), TypeOperand),
+                ExpressionType.TypeEqual =>
+                    SysExpr.TypeEqual(Expression.ToExpression(ref exprsConverted), TypeOperand),
+                _ => throw new NotSupportedException()
+            };
+            
     }
 
     public class MemberInitExpression : Expression, IArgumentProvider<MemberBinding>
@@ -4221,4 +4228,4 @@ public interface IParameterProvider
     }
 }
 
-//#endif
+//#endif

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -96,7 +96,9 @@ public enum NotSupported
         /// <summary>Goto of the Return kind from the TryCatch is not supported</summary>
         Try_GotoReturnToTheFollowupLabel,
         /// <summary>Not supported assignment target</summary>
-        Assign_Target
+        Assign_Target,
+        /// <summary> ExpressionType.TypeEqual is not supported </summary>
+        TypeEqual
     }
 
     /// <summary>FEC Not Supported exception</summary>
@@ -2693,15 +2695,20 @@ private static bool TryEmitTypeIsOrEqual(TypeBinaryExpression expr, IReadOnlyLis
                     return false;
 
                 if ((parent & ParentFlags.IgnoreResult) != 0)
-                    il.Emit(OpCodes.Pop);
-                else
+                    return true;
+                else if (expr.NodeType == ExpressionType.TypeIs)
                 {
                     il.Emit(OpCodes.Isinst, expr.TypeOperand);
                     il.Emit(OpCodes.Ldnull);
                     il.Emit(OpCodes.Cgt_Un);
+                    return true;
+                }
+                else
+                {
+                    if ((setup & CompilerFlags.ThrowOnNotSupportedExpression) != 0)
+                        throw new NotSupportedExpressionException(NotSupported.TypeEqual);
+                    return false;
                 }
-
-                return true;
             }
 
 #if LIGHT_EXPRESSION

test/FastExpressionCompiler.UnitTests/TestTools.cs

@@ -51,6 +51,8 @@ public static void PrintIL(this MethodInfo method, string tag = null)
 
         public static StringBuilder ToILString(this MethodInfo method, StringBuilder s = null)
         {
+            if (method is null) throw new ArgumentNullException(nameof(method));
+
             s = s ?? new StringBuilder();
 
             var ilReader = ILReaderFactory.Create(method);
@@ -64,7 +66,6 @@ public static StringBuilder ToILString(this MethodInfo method, StringBuilder s =
                         s.AppendLine();
                     else 
                         secondLine = true;
-                    
                     s.Append(il.Offset.ToString().PadRight(4, ' ')).Append(' ').Append(il.OpCode);
                     if (il is InlineFieldInstruction f)
                         s.Append(' ').Append(f.Field.DeclaringType.Name).Append('.').Append(f.Field.Name);

test/FastExpressionCompiler.UnitTests/TypeBinaryExpressionTests.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using NUnit.Framework;
 
 #if LIGHT_EXPRESSION
@@ -16,25 +16,30 @@ public int Run()
         {
             TypeEqual_should_work();
             TypeIs_should_work();
+            TypeIs_more_advanced();
 
-            return 2;
+            return 3;
         }
 
         [Test]
         public void TypeEqual_should_work()
         {
             var sExpr = Parameter(typeof(object), "o");
             var expr = Lambda<Func<object, bool>>(
-                TypeEqual(sExpr, typeof(string)),
+                TypeEqual(sExpr, typeof(A)),
                 sExpr);
 
-            var f = expr.CompileFast(true);
+            var f = expr.CompileSys(); // TODO: CompileFast, but it does not work ATM
             Assert.IsNotNull(f);
-            bool result = f("123");
-
-            Assert.IsTrue(result);
+            bool result = f(new A());
+            Assert.IsTrue(result, expr.ToString());
+            bool result2 = f(new B());
+            Assert.IsFalse(result2, expr.GetType().FullName);
         }
 
+        class A { }
+        class B: A { }
+
         [Test]
         public void TypeIs_should_work()
         {
@@ -48,5 +53,34 @@ public void TypeIs_should_work()
 
             Assert.IsTrue(result);
         }
+
+        [Test]
+        public void TypeIs_more_advanced()
+        {
+            var fromParam = Parameter(typeof(object));
+            var exprInt = Lambda<Func<object, bool>>(TypeIs(fromParam, typeof(int)), fromParam).CompileFast(true);
+            var exprX = Lambda<Func<object, bool>>(TypeIs(fromParam, typeof(S)), fromParam).CompileFast(true);
+            var exprXEnum = Lambda<Func<object, bool>>(TypeIs(fromParam, typeof(E)), fromParam).CompileFast(true);
+            var exprString = Lambda<Func<object, bool>>(TypeIs(fromParam, typeof(string)), fromParam).CompileFast(true);
+            var exprIgnoredResult = Lambda<Action<object>>(TypeIs(fromParam, typeof(string)), fromParam).CompileFast(true);
+
+            Assert.AreEqual(true, exprInt(1));
+            Assert.AreEqual(false, exprInt("A"));
+            Assert.AreEqual(false, exprInt(1L));
+            Assert.AreEqual(true, exprX(new S()));
+            Assert.AreEqual(false, exprX("A"));
+            Assert.AreEqual(false, exprX(null));
+            Assert.AreEqual(true, exprXEnum(E.A));
+            Assert.AreEqual(false, exprXEnum("A"));
+            Assert.AreEqual(false, exprXEnum(null));
+            Assert.AreEqual(true, exprString("A"));
+            Assert.AreEqual(false, exprString(E.A));
+            Assert.AreEqual(false, exprXEnum(null));
+            exprIgnoredResult(1);
+            exprIgnoredResult("A");
+        }
+
+        struct S { }
+        enum E { A }
     }
 }

test/FastExpressionCompiler.UnitTests/ValueTypeTests.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using NUnit.Framework;
 
 #if LIGHT_EXPRESSION
@@ -22,8 +22,9 @@ public int Run()
             Can_init_struct_member();
             Can_get_struct_member();
             Action_using_with_struct_closure_field();
+            Struct_Convert_to_interface();
 
-            return 7;
+            return 8;
         }
 
         [Test]
@@ -122,14 +123,27 @@ public void Action_using_with_struct_closure_field()
             Assert.AreEqual("a", s.Value);
         }
 
-        public struct SS
+        [Test]
+        public void Struct_Convert_to_interface()
+        {
+            Expression<Func<int, IComparable>> expr = a => a;
+            Expression<Func<DateTimeKind, IComparable>> expr2 = a => a;
+            Expression<Func<SS, IDisposable>> expr3 = a => a;
+
+            Assert.AreEqual(12, expr.CompileFast(ifFastFailedReturnNull: true)(12));
+            Assert.AreEqual(DateTimeKind.Local, expr2.CompileFast(ifFastFailedReturnNull: true)(DateTimeKind.Local));
+            Assert.AreEqual(new SS { Value = "a" }, expr3.CompileFast(ifFastFailedReturnNull: true)(new SS { Value = "a" }));
+        }
+
+        public struct SS: IDisposable
         {
             public string Value;
 
             public void SetValue(string s)
             {
                 Value = s;
             }
+            public void Dispose() { }
         }
     }
 }