more from #558; RefEquals,Or(bool?)

Author: dadhi

src/FastExpressionCompiler.LightExpression/Expression.cs

@@ -628,13 +628,13 @@ public static UnaryExpression Increment(Expression expression) =>
     /// <summary>Returns whether the expression evaluates to false.</summary>
     public static UnaryExpression IsFalse(Expression expression) =>
        Nullable.GetUnderlyingType(expression.Type) != null
-        ? new TypedUnaryExpression<bool?>(ExpressionType.IsFalse, expression) 
+        ? new TypedUnaryExpression<bool?>(ExpressionType.IsFalse, expression)
         : new TypedUnaryExpression<bool>(ExpressionType.IsFalse, expression);
 
     /// <summary>Returns whether the expression evaluates to true.</summary>
     public static UnaryExpression IsTrue(Expression expression) =>
-       Nullable.GetUnderlyingType(expression.Type) != null 
-        ? new TypedUnaryExpression<bool?>(ExpressionType.IsTrue, expression) 
+       Nullable.GetUnderlyingType(expression.Type) != null
+        ? new TypedUnaryExpression<bool?>(ExpressionType.IsTrue, expression)
         : new TypedUnaryExpression<bool>(ExpressionType.IsTrue, expression);
 
     /// <summary>Creates a UnaryExpression, given an operand and its type</summary>
@@ -2152,11 +2152,11 @@ public static SwitchCase SwitchCase(Expression body, params Expression[] testVal
 
     /// <summary>Creates a BinaryExpression that represents a reference equality comparison.</summary>
     public static BinaryExpression ReferenceEqual(Expression left, Expression right) =>
-        new LogicalBinaryExpression(ExpressionType.Equal, left, right);
+        new LogicalBinaryExpression(ExpressionType.Equal, left, right, isReferenceComparison: true);
 
     /// <summary>Creates a BinaryExpression that represents a reference inequality comparison.</summary>
     public static BinaryExpression ReferenceNotEqual(Expression left, Expression right) =>
-        new LogicalBinaryExpression(ExpressionType.NotEqual, left, right);
+        new LogicalBinaryExpression(ExpressionType.NotEqual, left, right, isReferenceComparison: true);
 
     /// <summary>Creates a BinaryExpression that represents a coalescing operation.</summary>
     [RequiresUnreferencedCode(Trimming.Message)]
@@ -2927,6 +2927,14 @@ internal static Expression ConvertToLightExpression(SysExpr sysExpr, ref SmallLi
                     var left = be.Left.ToLightExpression(ref exprsConverted);
                     var raft = be.Right.ToLightExpression(ref exprsConverted);
                     var conv = be.Conversion?.ToLightExpression(ref exprsConverted) as LambdaExpression;
+
+                    // System `ReferenceEqual`/`ReferenceNotEqual` are `Equal`/`NotEqual` without the method for the reference type operands,
+                    // for the types with `==` operator System binds the method, so the missing method means the reference comparison
+                    if ((nodeType == ExpressionType.Equal | nodeType == ExpressionType.NotEqual) &&
+                        be.Method == null && !be.IsLiftedToNull && be.Conversion == null &&
+                        !be.Left.Type.IsValueType && !be.Right.Type.IsValueType)
+                        return nodeType == ExpressionType.Equal ? Expression.ReferenceEqual(left, raft) : Expression.ReferenceNotEqual(left, raft);
+
                     return Expression.MakeBinary(nodeType, left, raft, be.IsLiftedToNull, be.Method, conv);
                 }
 
@@ -3563,11 +3571,23 @@ internal sealed class LogicalBinaryExpression : BinaryExpression
 {
     public override ExpressionType NodeType { get; }
     public override Type Type => typeof(bool);
-    internal LogicalBinaryExpression(ExpressionType nodeType, Expression left, Expression right) : base(left, right) =>
+    internal readonly bool IsReferenceComparison;
+    internal LogicalBinaryExpression(ExpressionType nodeType, Expression left, Expression right, bool isReferenceComparison = false) : base(left, right)
+    {
         NodeType = nodeType;
-
+        IsReferenceComparison = isReferenceComparison;
+    }
     internal override SysExpr CreateSysExpression(ref SmallList<LightAndSysExpr> exprsConverted)
     {
+        if (IsReferenceComparison)
+        {
+            var refLeft = Left.ToExpression(ref exprsConverted);
+            var refRight = Right.ToExpression(ref exprsConverted);
+            return NodeType == ExpressionType.Equal
+                ? SysExpr.ReferenceEqual(refLeft, refRight)
+                : SysExpr.ReferenceNotEqual(refLeft, refRight);
+        }
+
         if (NodeType == ExpressionType.Equal ||
             NodeType == ExpressionType.NotEqual)
         {
@@ -4077,7 +4097,7 @@ public class TwoArgumentsNewExpression : NewExpression
     public override IReadOnlyList<Expression> Arguments => new[] { Argument0, Argument1 };
     public override int ArgumentCount => 2;
     public override Expression GetArgument(int i) => _args.GetSurePresentRef(i).AsExpr();
-    internal TwoArgumentsNewExpression(ConstructorInfo constructor, object a0, object a1) : base(constructor) => 
+    internal TwoArgumentsNewExpression(ConstructorInfo constructor, object a0, object a1) : base(constructor) =>
         _args = new(a0, a1);
 }
 
@@ -4230,7 +4250,7 @@ public override Result TryCollectInfo(ref CompilerContext context, NestedLambdaI
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument1, nestedLambda, ref rootNestedLambdas)) != Result.OK) return r;
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument2, nestedLambda, ref rootNestedLambdas)) != Result.OK) return r;
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument3, nestedLambda, ref rootNestedLambdas)) != Result.OK) return r;
-        return   ExpressionCompiler.TryCollectInfo(ref context, Argument4, nestedLambda, ref rootNestedLambdas);
+        return ExpressionCompiler.TryCollectInfo(ref context, Argument4, nestedLambda, ref rootNestedLambdas);
     }
 
     [RequiresUnreferencedCode(Trimming.Message)]
@@ -4284,7 +4304,7 @@ public override Result TryCollectInfo(ref CompilerContext context, NestedLambdaI
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument2, nestedLambda, ref rootNestedLambdas)) != Result.OK) return r;
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument3, nestedLambda, ref rootNestedLambdas)) != Result.OK) return r;
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument4, nestedLambda, ref rootNestedLambdas)) != Result.OK) return r;
-        return   ExpressionCompiler.TryCollectInfo(ref context, Argument5, nestedLambda, ref rootNestedLambdas);
+        return ExpressionCompiler.TryCollectInfo(ref context, Argument5, nestedLambda, ref rootNestedLambdas);
     }
 
     [RequiresUnreferencedCode(Trimming.Message)]
@@ -4341,7 +4361,7 @@ public override Result TryCollectInfo(ref CompilerContext context, NestedLambdaI
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument3, nestedLambda, ref rootNestedLambdas)) != 0) return r;
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument4, nestedLambda, ref rootNestedLambdas)) != 0) return r;
         if ((r = ExpressionCompiler.TryCollectInfo(ref context, Argument5, nestedLambda, ref rootNestedLambdas)) != 0) return r;
-        return   ExpressionCompiler.TryCollectInfo(ref context, Argument6, nestedLambda, ref rootNestedLambdas);
+        return ExpressionCompiler.TryCollectInfo(ref context, Argument6, nestedLambda, ref rootNestedLambdas);
     }
 
     [RequiresUnreferencedCode(Trimming.Message)]

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -2020,6 +2020,10 @@ public static bool TryEmit(Expression expr, ILGenerator il, ref CompilerContext
                                 var comparison = (BinaryExpression)expr;
                                 if (comparison.Method != null && !comparison.IsLifted)
                                     return TryEmitComparisonMethod(comparison, il, ref context, parent);
+#if LIGHT_EXPRESSION
+                                if (comparison is LogicalBinaryExpression { IsReferenceComparison: true })
+                                    return TryEmitReferenceComparison(comparison, nodeType == ExpressionType.NotEqual, il, ref context, parent);
+#endif
                                 if (exprType.IsPrimitive && Interpreter.TryInterpretBool(out var boolResult, expr, context.CompilerFlags))
                                 {
                                     if ((parent & ParentFlags.IgnoreResult) == 0)
@@ -2042,9 +2046,9 @@ public static bool TryEmit(Expression expr, ILGenerator il, ref CompilerContext
                                 var binary = (BinaryExpression)expr;
                                 var binaryLeft = binary.Left;
                                 var binaryRight = binary.Right;
-                                if (nodeType == ExpressionType.And && binary.Method == null &&
+                                if ((nodeType == ExpressionType.And || nodeType == ExpressionType.Or) && binary.Method == null &&
                                     exprType == typeof(bool?) && binaryLeft.Type == typeof(bool?) && binaryRight.Type == typeof(bool?))
-                                    return TryEmitNullableBooleanAnd(binaryLeft, binaryRight, il, ref context, parent);
+                                    return TryEmitNullableBooleanAndOr(binaryLeft, binaryRight, nodeType == ExpressionType.And, il, ref context, parent);
 
                                 return exprType.IsPrimitive
                                     && TryInterpretAndEmitResult(expr, il, parent, context.CompilerFlags)
@@ -5591,6 +5595,26 @@ private static MethodInfo FindBinaryOperandMethod(
                 return null;
             }
 
+#if LIGHT_EXPRESSION
+            // `ReferenceEqual` and `ReferenceNotEqual` compare the references even when the type defines the `==` operator, e.g. string
+            private static bool TryEmitReferenceComparison(BinaryExpression expr, bool isNotEqual, ILGenerator il,
+                ref CompilerContext context, ParentFlags parent)
+            {
+                var flags = parent
+                    & ~(ParentFlags.IgnoreResult | ParentFlags.InstanceCall |
+                        ParentFlags.LambdaCall | ParentFlags.ReturnByRef);
+
+                if (!TryEmit(expr.Left, il, ref context, flags) ||
+                    !TryEmit(expr.Right, il, ref context, flags))
+                    return false;
+
+                il.Demit(OpCodes.Ceq);
+                if (isNotEqual)
+                    EmitEqualToZeroOrNull(il);
+                return il.EmitPopIfIgnoreResult(parent);
+            }
+#endif
+
             private static bool TryEmitComparisonMethod(BinaryExpression expr, ILGenerator il, ref CompilerContext context, ParentFlags parent)
             {
                 var method = expr.Method;
@@ -6022,7 +6046,7 @@ private static bool TryEmitArithmetic(Expression left, Expression right, Express
                 return true;
             }
 
-            private static bool TryEmitNullableBooleanAnd(Expression left, Expression right, ILGenerator il,
+            private static bool TryEmitNullableBooleanAndOr(Expression left, Expression right, bool isAnd, ILGenerator il,
                 ref CompilerContext context, ParentFlags parent)
             {
                 var flags = (parent
@@ -6038,7 +6062,7 @@ private static bool TryEmitNullableBooleanAnd(Expression left, Expression right,
                     return false;
                 var rightVar = EmitStoreLocalVariable(il, typeof(bool?));
 
-                var falseLabel = il.DefineLabel();
+                var absorbLabel = il.DefineLabel();
                 var nullLabel = il.DefineLabel();
                 var doneLabel = il.DefineLabel();
 
@@ -6052,13 +6076,13 @@ private static bool TryEmitNullableBooleanAnd(Expression left, Expression right,
                 il.Demit(OpCodes.Brfalse, nullLabel);
                 EmitLoadLocalVariableAddress(il, rightVar);
                 il.Demit(OpCodes.Ldfld, typeof(bool?).GetNullableValueUnsafeAkaGetValueOrDefaultMethod());
-                il.Demit(OpCodes.Brtrue, nullLabel);
-                il.Demit(OpCodes.Br, falseLabel);
+                il.Demit(isAnd ? OpCodes.Brtrue : OpCodes.Brfalse, nullLabel);
+                il.Demit(OpCodes.Br, absorbLabel);
 
                 il.DmarkLabel(leftHasValueLabel);
                 EmitLoadLocalVariableAddress(il, leftVar);
                 il.Demit(OpCodes.Ldfld, typeof(bool?).GetNullableValueUnsafeAkaGetValueOrDefaultMethod());
-                il.Demit(OpCodes.Brfalse, falseLabel);
+                il.Demit(isAnd ? OpCodes.Brfalse : OpCodes.Brtrue, absorbLabel);
                 EmitLoadLocalVariableAddress(il, rightVar);
                 EmitMethodCall(il, typeof(bool?).GetNullableHasValueGetterMethod());
                 il.Demit(OpCodes.Brfalse, nullLabel);
@@ -6067,8 +6091,8 @@ private static bool TryEmitNullableBooleanAnd(Expression left, Expression right,
                 il.Demit(OpCodes.Newobj, typeof(bool?).GetNullableConstructor());
                 il.Demit(OpCodes.Br, doneLabel);
 
-                il.DmarkLabel(falseLabel);
-                il.Demit(OpCodes.Ldc_I4_0);
+                il.DmarkLabel(absorbLabel);
+                il.Demit(isAnd ? OpCodes.Ldc_I4_0 : OpCodes.Ldc_I4_1);
                 il.Demit(OpCodes.Newobj, typeof(bool?).GetNullableConstructor());
                 il.Demit(OpCodes.Br, doneLabel);
 
@@ -10076,6 +10100,15 @@ internal static StringBuilder CreateExpressionString(this Expression e, StringBu
 
                         if (e is BinaryExpression b)
                         {
+#if LIGHT_EXPRESSION
+                            if (b is LogicalBinaryExpression { IsReferenceComparison: true })
+                            {
+                                sb.Append(e.NodeType == ExpressionType.Equal ? "ReferenceEqual(" : "ReferenceNotEqual(");
+                                sb.NewLineIndentExpr(b.Left, paramsExprs, uniqueExprs, lts, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).Append(',');
+                                sb.NewLineIndentExpr(b.Right, paramsExprs, uniqueExprs, lts, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode);
+                                return sb.Append(')');
+                            }
+#endif
                             sb.Append("MakeBinary(").Append(typeof(ExpressionType).Name).Append('.').Append(name).Append(',');
                             sb.NewLineIndentExpr(b.Left, paramsExprs, uniqueExprs, lts, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).Append(',');
                             sb.NewLineIndentExpr(b.Right, paramsExprs, uniqueExprs, lts, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode);
@@ -10098,7 +10131,7 @@ internal static StringBuilder CreateExpressionString(this Expression e, StringBu
     }
 
     /// <summary>Provides structural equality comparison for expression trees (both LightExpression and System.Linq.Expressions).
-    /// Use the static <see cref="EqualsTo"/> method as the primary entry point — it creates a temporary struct on the stack with no heap allocation.
+    /// Use the static <see cref="EqualsTo"/> method as the primary entry point — it creates a temporary struct on the stack with no heap allocation.
     /// Parameters are matched by their position within their enclosing lambda or block, and label targets by identity pairing.
     /// Up to 8 lambda parameters and label targets are stored on the stack; larger numbers spill to a heap array.</summary>
     public struct ExpressionEqualityComparer : IEqualityComparer<Expression>, IEqualityComparer
@@ -10108,7 +10141,7 @@ public struct ExpressionEqualityComparer : IEqualityComparer<Expression>, IEqual
         private SmallList<ParameterExpression, Stack8<ParameterExpression>, NoArrayPool<ParameterExpression>> _xps, _yps;
         private SmallList<LabelTarget, Stack8<LabelTarget>, NoArrayPool<LabelTarget>> _xls, _yls;
 
-        /// <summary>Structurally compares two expressions. Primary entry point — no heap allocation for the comparer.</summary>
+        /// <summary>Structurally compares two expressions. Primary entry point — no heap allocation for the comparer.</summary>
         [MethodImpl((MethodImplOptions)256)]
         public static bool EqualsTo(Expression x, Expression y) =>
             new ExpressionEqualityComparer().Eq(x, y);
@@ -10300,19 +10333,19 @@ private int Hash(Expression expr)
             }
         }
 
-        /// <summary>IEqualityComparer&lt;Expression&gt; implementation — delegates to the static <see cref="EqualsTo"/> for a fresh context per call.</summary>
+        /// <summary>IEqualityComparer&lt;Expression&gt; implementation — delegates to the static <see cref="EqualsTo"/> for a fresh context per call.</summary>
         [MethodImpl((MethodImplOptions)256)]
         bool IEqualityComparer<Expression>.Equals(Expression x, Expression y) => EqualsTo(x, y);
 
-        /// <summary>IEqualityComparer&lt;Expression&gt; implementation — delegates to the static <see cref="GetHashCode(Expression)"/>.</summary>
+        /// <summary>IEqualityComparer&lt;Expression&gt; implementation — delegates to the static <see cref="GetHashCode(Expression)"/>.</summary>
         [MethodImpl((MethodImplOptions)256)]
         int IEqualityComparer<Expression>.GetHashCode(Expression obj) => GetHashCode(obj);
 
-        /// <summary>Non-generic IEqualityComparer implementation — delegates to the static methods for use with legacy BCL APIs.</summary>
+        /// <summary>Non-generic IEqualityComparer implementation — delegates to the static methods for use with legacy BCL APIs.</summary>
         [MethodImpl((MethodImplOptions)256)]
         bool IEqualityComparer.Equals(object x, object y) => EqualsTo(x as Expression, y as Expression);
 
-        /// <summary>Non-generic IEqualityComparer implementation — delegates to the static <see cref="GetHashCode(Expression)"/>.</summary>
+        /// <summary>Non-generic IEqualityComparer implementation — delegates to the static <see cref="GetHashCode(Expression)"/>.</summary>
         [MethodImpl((MethodImplOptions)256)]
         int IEqualityComparer.GetHashCode(object obj) => GetHashCode(obj as Expression);
 
@@ -11597,6 +11630,19 @@ void PrintPart(Expression part, ref PrintContext ctx)
                             if (containerIgnoresResult | enclosedIn == EnclosedIn.Block)
                                 sb.Append("_ = "); // apply for non assignments
 
+#if LIGHT_EXPRESSION
+                            if (b is LogicalBinaryExpression { IsReferenceComparison: true })
+                            {
+                                if (nodeType == ExpressionType.NotEqual)
+                                    sb.Append('!');
+                                sb.Append("object.ReferenceEquals(");
+                                b.Left.ToCSharpExpression(sb, EnclosedIn.AvoidParens, ref ctx,
+                                    false, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).Append(", ");
+                                return b.Right.ToCSharpExpression(sb, EnclosedIn.AvoidParens, ref ctx,
+                                    false, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).Append(')');
+                            }
+#endif
+
                             sb = sb.AddParenIfNeeded('(', avoidParens);
                             b.Left.ToCSharpExpression(sb, EnclosedIn.ParensByDefault, ref ctx,
                                 false, lineIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode);