Add option to ParsingConfig to allow the Equals and ToString methods on object (#875)

StefH · web-flow · commit 1934a14aa49f · 2025-01-24T18:10:59.000+01:00
* Add option to ParsingConfig to allow the Equals and ToString methods on object

* .

* ---

* ReferenceEquals

* .
diff --git a/src-blazor/BlazorAppServer/BlazorAppServer.csproj b/src-blazor/BlazorAppServer/BlazorAppServer.csproj
@@ -17,9 +17,7 @@
         <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
         <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
         <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
-        <PackageReference Include="Oqtane.Shared" Version="3.1.4" />
         <PackageReference Include="System.Configuration.ConfigurationManager" Version="6.0.0" />
-        <!--<PackageReference Include="System.Linq.Dynamic.Core" Version="1.2.19" />-->
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/System.Linq.Dynamic.Core/Compatibility/TypeExtensions.cs b/src/System.Linq.Dynamic.Core/Compatibility/TypeExtensions.cs
@@ -1,4 +1,4 @@
-﻿#if NETSTANDARD1_3
+﻿#if NETSTANDARD1_3 || UAP10_0
 using System.Linq;
 
 namespace System.Reflection;
diff --git a/src/System.Linq.Dynamic.Core/DynamicClassFactory.cs b/src/System.Linq.Dynamic.Core/DynamicClassFactory.cs
@@ -1,8 +1,9 @@
-﻿#if !(UAP10_0)
+﻿#if !UAP10_0
 using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq.Dynamic.Core.Parser;
 using System.Linq.Dynamic.Core.Validation;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -27,12 +28,6 @@ public static class DynamicClassFactory
 
     private static readonly ConstructorInfo ObjectCtor = typeof(object).GetConstructor(Type.EmptyTypes)!;
 
-#if UAP10_0 || NETSTANDARD
-    private static readonly MethodInfo ObjectToString = typeof(object).GetMethod(nameof(ToString), BindingFlags.Instance | BindingFlags.Public)!;
-#else
-    private static readonly MethodInfo ObjectToString = typeof(object).GetMethod(nameof(ToString), BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null)!;
-#endif
-
     private static readonly ConstructorInfo StringBuilderCtor = typeof(StringBuilder).GetConstructor(Type.EmptyTypes)!;
 #if UAP10_0 || NETSTANDARD
     private static readonly MethodInfo StringBuilderAppendString = typeof(StringBuilder).GetMethod(nameof(StringBuilder.Append), [typeof(string)])!;
@@ -419,7 +414,7 @@ private static Type EmitType(IList<DynamicProperty> properties, bool createParam
         ilgeneratorToString.Emit(OpCodes.Callvirt, StringBuilderAppendString);
         ilgeneratorToString.Emit(OpCodes.Pop);
         ilgeneratorToString.Emit(OpCodes.Ldloc_0);
-        ilgeneratorToString.Emit(OpCodes.Callvirt, ObjectToString);
+        ilgeneratorToString.Emit(OpCodes.Callvirt, PredefinedMethodsHelper.ObjectToString);
         ilgeneratorToString.Emit(OpCodes.Ret);
 
         EmitEqualityOperators(typeBuilder, equals);
diff --git a/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs b/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs
@@ -1840,9 +1840,9 @@ private Expression ParseMemberAccess(Type? type, Expression? expression, string?
 
                 case 1:
                     var method = (MethodInfo)methodBase!;
-                    if (!PredefinedTypesHelper.IsPredefinedType(_parsingConfig, method.DeclaringType!))
+                    if (!PredefinedTypesHelper.IsPredefinedType(_parsingConfig, method.DeclaringType!) && !PredefinedMethodsHelper.IsPredefinedMethod(_parsingConfig, method))
                     {
-                        throw ParseError(errorPos, Res.MethodsAreInaccessible, TypeHelper.GetTypeName(method.DeclaringType!));
+                        throw ParseError(errorPos, Res.MethodIsInaccessible, id, TypeHelper.GetTypeName(method.DeclaringType!));
                     }
 
                     MethodInfo methodToCall;
diff --git a/src/System.Linq.Dynamic.Core/Parser/PredefinedMethodsHelper.cs b/src/System.Linq.Dynamic.Core/Parser/PredefinedMethodsHelper.cs
@@ -0,0 +1,30 @@
+﻿using System.Collections.Generic;
+using System.Linq.Dynamic.Core.Validation;
+using System.Reflection;
+
+namespace System.Linq.Dynamic.Core.Parser;
+
+internal static class PredefinedMethodsHelper
+{
+    internal static readonly MethodInfo ObjectToString = typeof(object).GetMethod(nameof(ToString), BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null)!;
+    internal static readonly MethodInfo ObjectInstanceEquals = typeof(object).GetMethod(nameof(Equals), BindingFlags.Instance | BindingFlags.Public, null, [typeof(object)], null)!;
+    internal static readonly MethodInfo ObjectStaticEquals = typeof(object).GetMethod(nameof(Equals), BindingFlags.Static | BindingFlags.Public, null, [typeof(object), typeof(object)], null)!;
+    internal static readonly MethodInfo ObjectStaticReferenceEquals = typeof(object).GetMethod(nameof(ReferenceEquals), BindingFlags.Static | BindingFlags.Public, null, [typeof(object), typeof(object)], null)!;
+
+
+    private static readonly HashSet<MemberInfo> ObjectToStringAndObjectEquals =
+    [
+        ObjectToString,
+        ObjectInstanceEquals,
+        ObjectStaticEquals,
+        ObjectStaticReferenceEquals
+    ];
+
+    public static bool IsPredefinedMethod(ParsingConfig config, MemberInfo member)
+    {
+        Check.NotNull(config);
+        Check.NotNull(member);
+
+        return config.AllowEqualsAndToStringMethodsOnObject && ObjectToStringAndObjectEquals.Contains(member);
+    }
+}
diff --git a/src/System.Linq.Dynamic.Core/ParsingConfig.cs b/src/System.Linq.Dynamic.Core/ParsingConfig.cs
@@ -312,4 +312,11 @@ public IQueryableAnalyzer QueryableAnalyzer
     /// Default value is <c>false</c>.
     /// </summary>
     public bool RestrictOrderByToPropertyOrField { get; set; }
+
+    /// <summary>
+    /// When set to <c>true</c>, the parser will allow the use of the Equals(object obj), Equals(object objA, object objB), ReferenceEquals(object objA, object objB) and ToString() methods on the <see cref="object"/> type.
+    ///
+    /// Default value is <c>false</c>.
+    /// </summary>
+    public bool AllowEqualsAndToStringMethodsOnObject { get; set; }
 }
diff --git a/src/System.Linq.Dynamic.Core/Res.cs b/src/System.Linq.Dynamic.Core/Res.cs
@@ -50,7 +50,7 @@ internal static class Res
     public const string InvalidStringLength = "String '{0}' should have at least {1} characters.";
     public const string IsNullRequiresTwoArgs = "The 'isnull' function requires two arguments";
     public const string MethodIsVoid = "Method '{0}' in type '{1}' does not return a value";
-    public const string MethodsAreInaccessible = "Methods on type '{0}' are not accessible";
+    public const string MethodIsInaccessible = "Method '{0}' on type '{1}' is not accessible.";
     public const string MinusCannotBeAppliedToUnsignedInteger = "'-' cannot be applied to unsigned integers.";
     public const string MissingAsClause = "Expression is missing an 'as' clause";
     public const string NeitherTypeConvertsToOther = "Neither of the types '{0}' and '{1}' converts to the other";
diff --git a/test/System.Linq.Dynamic.Core.Tests/DynamicClassTest.cs b/test/System.Linq.Dynamic.Core.Tests/DynamicClassTest.cs
@@ -281,11 +281,15 @@ public void DynamicClassArray_Issue593_Fails()
         isValid.Should().BeFalse(); // This should actually be true, but fails. For solution see Issue593_Solution1 and Issue593_Solution2.
     }
 
-    // [SkipIfGitHubActions]
-    [Fact(Skip = "867")]
+    [SkipIfGitHubActions]
     public void DynamicClassArray_Issue593_Solution1()
     {
         // Arrange
+        var config = new ParsingConfig
+        {
+            AllowEqualsAndToStringMethodsOnObject = true
+        };
+
         var field = new
         {
             Name = "firstName",
@@ -308,7 +312,7 @@ public void DynamicClassArray_Issue593_Solution1()
         var query = dynamicClasses.AsQueryable();
 
         // Act
-        var isValid = query.Any("firstName.ToString() eq \"firstValue\"");
+        var isValid = query.Any(config, "firstName.ToString() eq \"firstValue\"");
 
         // Assert
         isValid.Should().BeTrue();
diff --git a/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs b/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs
@@ -1058,13 +1058,23 @@ public void DynamicExpressionParser_ParseLambda_StringLiteral_QuotationMark()
         Assert.Equal(expectedRightValue, rightValue);
     }
 
-    [Fact(Skip = "867")]
+    [Fact]
     public void DynamicExpressionParser_ParseLambda_TupleToStringMethodCall_ReturnsStringLambdaExpression()
     {
+        // Arrange
+        var config = new ParsingConfig
+        {
+            AllowEqualsAndToStringMethodsOnObject = true
+        };
+
+        // Act
         var expression = DynamicExpressionParser.ParseLambda(
+            config,
             typeof(Tuple<int>),
             typeof(string),
             "it.ToString()");
+
+        // Assert
         Assert.Equal(typeof(string), expression.ReturnType);
     }
 
@@ -1147,7 +1157,7 @@ public void DynamicExpressionParser_ParseLambda_CustomMethod_WhenClassDoesNotHav
         Action action = () => DynamicExpressionParser.ParseLambda(typeof(CustomClassWithMethod), null, expression);
 
         // Assert
-        action.Should().Throw<ParseException>().WithMessage("Methods on type 'CustomClassWithMethod' are not accessible");
+        action.Should().Throw<ParseException>().WithMessage("Method 'GetAge' on type 'CustomClassWithMethod' is not accessible.");
     }
 
     // [Fact]
diff --git a/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.cs b/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.cs
@@ -346,7 +346,8 @@ public void Parse_NullableShouldReturnNullable(string expression, object resultT
     [Theory]
     [InlineData("it.MainCompany.Name != null", "(company.MainCompany.Name != null)")]
     [InlineData("@MainCompany.Companies.Count() > 0", "(company.MainCompany.Companies.Count() > 0)")]
-    // [InlineData("Company.Equals(null, null)", "Equals(null, null)")] issue 867
+    [InlineData("Company.Equals(null, null)", "Equals(null, null)")]
+    [InlineData("Equals(null)", "company.Equals(null)")]
     [InlineData("MainCompany.Name", "company.MainCompany.Name")]
     [InlineData("Name", "company.Name")]
     [InlineData("company.Name", "company.Name")]
@@ -357,7 +358,8 @@ public void Parse_When_PrioritizePropertyOrFieldOverTheType_IsTrue(string expres
         var config = new ParsingConfig
         {
             IsCaseSensitive = true,
-            CustomTypeProvider = _dynamicTypeProviderMock.Object
+            CustomTypeProvider = _dynamicTypeProviderMock.Object,
+            AllowEqualsAndToStringMethodsOnObject = true
         };
         ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "company") };
         var sut = new ExpressionParser(parameters, expression, null, config);
diff --git a/test/System.Linq.Dynamic.Core.Tests/Parser/MethodFinderTest.cs b/test/System.Linq.Dynamic.Core.Tests/Parser/MethodFinderTest.cs
@@ -7,16 +7,93 @@ namespace System.Linq.Dynamic.Core.Tests.Parser;
 
 public class MethodFinderTest
 {
-    [Fact(Skip = "867")]
-    public void MethodsOfDynamicLinqAndSystemLinqShouldBeEqual()
+    [Fact]
+    public void Method_ToString_OnDynamicLinq_And_SystemLinq_ShouldBeEqual()
     {
+        // Arrange
+        var config = new ParsingConfig
+        {
+            AllowEqualsAndToStringMethodsOnObject = true
+        };
+
         Expression<Func<int?, string?>> expr = x => x.ToString();
-            
+
         var selector = "ToString()";
         var prm = Parameter(typeof(int?));
-        var parser = new ExpressionParser([prm], selector, [], ParsingConfig.Default);
-        var expr1 = parser.Parse(null);
-            
-        Assert.Equal(((MethodCallExpression)expr.Body).Method.DeclaringType, ((MethodCallExpression)expr1).Method.DeclaringType);
+        var parser = new ExpressionParser([prm], selector, [], config);
+
+        // Act
+        var expression = parser.Parse(null);
+
+        // Assert
+        Assert.Equal(((MethodCallExpression)expr.Body).Method.DeclaringType, ((MethodCallExpression)expression).Method.DeclaringType);
+    }
+
+    [Fact]
+    public void Method_Equals1_OnDynamicLinq_And_SystemLinq_ShouldBeEqual()
+    {
+        // Arrange
+        var config = new ParsingConfig
+        {
+            AllowEqualsAndToStringMethodsOnObject = true
+        };
+
+        Expression<Func<int?, bool>> expr = x => x.Equals("a");
+
+        var selector = "Equals(\"a\")";
+        var prm = Parameter(typeof(int?));
+        var parser = new ExpressionParser([prm], selector, [], config);
+
+        // Act
+        var expression = parser.Parse(null);
+
+        // Assert
+        Assert.Equal(((MethodCallExpression)expr.Body).Method.DeclaringType, ((MethodCallExpression)expression).Method.DeclaringType);
+    }
+
+    [Fact]
+    public void Method_Equals2_OnDynamicLinq_And_SystemLinq_ShouldBeEqual()
+    {
+        // Arrange
+        var config = new ParsingConfig
+        {
+            AllowEqualsAndToStringMethodsOnObject = true
+        };
+
+        // ReSharper disable once RedundantNameQualifier
+        Expression<Func<int?, bool>> expr = x => object.Equals("a", "b");
+
+        var selector = "object.Equals(\"a\", \"b\")";
+        var prm = Parameter(typeof(int?));
+        var parser = new ExpressionParser([prm], selector, [], config);
+
+        // Act
+        var expression = parser.Parse(null);
+
+        // Assert
+        Assert.Equal(((MethodCallExpression)expr.Body).Method.DeclaringType, ((MethodCallExpression)expression).Method.DeclaringType);
+    }
+
+    [Fact]
+    public void Method_ReferenceEquals_OnDynamicLinq_And_SystemLinq_ShouldBeEqual()
+    {
+        // Arrange
+        var config = new ParsingConfig
+        {
+            AllowEqualsAndToStringMethodsOnObject = true
+        };
+
+        // ReSharper disable once RedundantNameQualifier
+        Expression<Func<int?, bool>> expr = x => object.ReferenceEquals("a", "b");
+
+        var selector = "object.ReferenceEquals(\"a\", \"b\")";
+        var prm = Parameter(typeof(int?));
+        var parser = new ExpressionParser([prm], selector, [], config);
+
+        // Act
+        var expression = parser.Parse(null);
+
+        // Assert
+        Assert.Equal(((MethodCallExpression)expr.Body).Method.DeclaringType, ((MethodCallExpression)expression).Method.DeclaringType);
     }
 }
diff --git a/test/System.Linq.Dynamic.Core.Tests/SecurityTests.cs b/test/System.Linq.Dynamic.Core.Tests/SecurityTests.cs
@@ -31,7 +31,7 @@ public void MethodsShouldOnlyBeCallableOnPredefinedTypes_Test1()
         Action action = () => baseQuery.OrderBy(predicate);
 
         // Assert
-        action.Should().Throw<ParseException>().WithMessage("Methods on type 'Object' are not accessible");
+        action.Should().Throw<ParseException>().WithMessage("Method 'GetType' on type 'Object' is not accessible.");
     }
 
     [Fact]
@@ -48,19 +48,19 @@ public void MethodsShouldOnlyBeCallableOnPredefinedTypes_Test2()
         );
 
         // Assert
-        action.Should().Throw<ParseException>().WithMessage($"Methods on type 'Object' are not accessible");
+        action.Should().Throw<ParseException>().WithMessage("Method 'GetType' on type 'Object' is not accessible.");
     }
 
     [Theory]
-    [InlineData(typeof(FileStream), "Close()", "Stream")]
-    [InlineData(typeof(Assembly), "GetName().Name.ToString()", "Assembly")]
-    public void DynamicExpressionParser_ParseLambda_IllegalMethodCall_ThrowsException(Type itType, string expression, string type)
+    [InlineData(typeof(FileStream), "Close()", "Method 'Close' on type 'Stream' is not accessible.")]
+    [InlineData(typeof(Assembly), "GetName().Name.ToString()", "Method 'GetName' on type 'Assembly' is not accessible.")]
+    public void DynamicExpressionParser_ParseLambda_IllegalMethodCall_ThrowsException(Type itType, string expression, string errorMessage)
     {
         // Act
         Action action = () => DynamicExpressionParser.ParseLambda(itType, null, expression);
 
         // Assert
-        action.Should().Throw<ParseException>().WithMessage($"Methods on type '{type}' are not accessible");
+        action.Should().Throw<ParseException>().WithMessage(errorMessage);
     }
 
     [Theory]
@@ -79,7 +79,7 @@ public void UsingSystemReflectionAssembly_ThrowsException(string selector)
         Action action = () => queryable.Select(selector);
 
         // Assert
-        action.Should().Throw<ParseException>().WithMessage("Methods on type 'Object' are not accessible");
+        action.Should().Throw<ParseException>().WithMessage("Method 'GetType' on type 'Object' is not accessible.");
     }
 
     [Theory]

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#if NETSTANDARD1_3`
	`1`	`+#if NETSTANDARD1_3 \|\| UAP10_0`
`2`	`2`	`using System.Linq;`
`3`	`3`
`4`	`4`	`namespace System.Reflection;`
Original file line number	Diff line number	Diff line change
`@@ -1840,9 +1840,9 @@ private Expression ParseMemberAccess(Type? type, Expression? expression, string?`
`1840`	`1840`
`1841`	`1841`	`case 1:`
`1842`	`1842`	`var method = (MethodInfo)methodBase!;`
`1843`		`- if (!PredefinedTypesHelper.IsPredefinedType(_parsingConfig, method.DeclaringType!))`
	`1843`	`+ if (!PredefinedTypesHelper.IsPredefinedType(_parsingConfig, method.DeclaringType!) && !PredefinedMethodsHelper.IsPredefinedMethod(_parsingConfig, method))`
`1844`	`1844`	`{`
`1845`		`- throw ParseError(errorPos, Res.MethodsAreInaccessible, TypeHelper.GetTypeName(method.DeclaringType!));`
	`1845`	`+ throw ParseError(errorPos, Res.MethodIsInaccessible, id, TypeHelper.GetTypeName(method.DeclaringType!));`
`1846`	`1846`	`}`
`1847`	`1847`
`1848`	`1848`	`MethodInfo methodToCall;`