Fixed BindingEvaluator to properly support CompiledBinding in Avalonia 12 CR:xfortin (#623)

Author: Samuel-B-D

src/Devolutions.AvaloniaControls/Helpers/BindingEvaluator.cs

@@ -12,7 +12,6 @@ namespace Devolutions.AvaloniaControls.Helpers;
 using Avalonia.Data;
 using Avalonia.Data.Converters;
 using Avalonia.LogicalTree;
-using Avalonia.Markup.Xaml.MarkupExtensions;
 
 [RequiresUnreferencedCode("BindingEvaluator require preserved types")]
 [RequiresDynamicCode("BindingEvaluator require preserved types")]
@@ -132,6 +131,11 @@ public BindingEvaluator(StyledElement anchor, Type dataContextType)
             return getter;
         }
 
+        if (this.TryBuildIntermediateRawGetter(binding, out getter))
+        {
+            return getter;
+        }
+
         return this.BuildProxyRawGetter(binding);
     }
 
@@ -142,6 +146,11 @@ public BindingEvaluator(StyledElement anchor, Type dataContextType)
             return expression;
         }
 
+        if (TryBuildIntermediateRawExpression(binding, out expression))
+        {
+            return expression;
+        }
+
         return this.BuildProxyRawGetterExpression<TDataContext>(binding);
     }
 
@@ -153,34 +162,29 @@ public BindingEvaluator(StyledElement anchor, Type dataContextType)
         }
 
         ParameterExpression rowParameter = Expression.Parameter(typeof(TDataContext), "row");
-        Expression propertyAccess = rowParameter;
+        Expression propertyAccess;
 
         try
         {
-            foreach (string propertyName in path.Split('.'))
-            {
-                propertyAccess = Expression.PropertyOrField(propertyAccess, propertyName);
-            }
+            propertyAccess = BuildNullSafePropertyAccess(rowParameter, path);
         }
         catch
         {
             return null;
         }
 
-        if (propertyAccess.Type == typeof(string))
-        {
-            Expression body = Expression.Coalesce(propertyAccess, Expression.Constant(string.Empty));
-            return Expression.Lambda<Func<TDataContext, string>>(body, rowParameter);
-        }
-
-        Expression toStringExpr = ToStringExpression(propertyAccess);
-        Expression<Func<TDataContext, string>> innerLambda = Expression.Lambda<Func<TDataContext, string>>(toStringExpr, rowParameter);
-        Func<TDataContext, string?> compiledGetter = innerLambda.Compile();
-
-        ParameterExpression outerParam = Expression.Parameter(typeof(TDataContext), "row");
-        Expression outerBody = Expression.Invoke(Expression.Constant(compiledGetter), outerParam);
-
-        return Expression.Lambda<Func<TDataContext, string>>(outerBody, outerParam);
+        ParameterExpression value = Expression.Variable(typeof(object), "value");
+        Expression missingValue = Expression.OrElse(
+            Expression.ReferenceEqual(value, Expression.Constant(null)),
+            Expression.ReferenceEqual(value, Expression.Constant(AvaloniaProperty.UnsetValue)));
+        Expression valueAsString = Expression.Coalesce(
+            Expression.Call(value, objectToStringMethod),
+            Expression.Constant(string.Empty));
+        Expression body = Expression.Block(
+            [value],
+            Expression.Assign(value, propertyAccess),
+            Expression.Condition(missingValue, Expression.Constant(string.Empty), valueAsString));
+        return Expression.Lambda<Func<TDataContext, string>>(body, rowParameter);
     }
 
     private static Expression<Func<TDataContext, object?>>? BuildFastPathRawExpression<TDataContext>(string path)
@@ -191,40 +195,53 @@ public BindingEvaluator(StyledElement anchor, Type dataContextType)
         }
 
         ParameterExpression rowParameter = Expression.Parameter(typeof(TDataContext), "row");
-        Expression propertyAccess = rowParameter;
+        Expression body;
 
         try
         {
-            foreach (string propertyName in path.Split('.'))
-            {
-                propertyAccess = Expression.PropertyOrField(propertyAccess, propertyName);
-            }
+            body = BuildNullSafePropertyAccess(rowParameter, path);
         }
         catch
         {
             return null;
         }
 
-        Expression body = propertyAccess.Type.IsValueType ? Expression.Convert(propertyAccess, typeof(object)) : propertyAccess;
         return Expression.Lambda<Func<TDataContext, object?>>(body, rowParameter);
     }
 
     private static Func<object, object?> BuildPropertyGetter(string path, Type rootType)
     {
         ParameterExpression param = Expression.Parameter(typeof(object), "root");
-        Expression access = Expression.Convert(param, rootType);
+        Expression access = BuildNullSafePropertyAccess(Expression.Convert(param, rootType), path);
 
-        foreach (string propertyName in path.Split('.'))
-        {
-            access = Expression.PropertyOrField(access, propertyName);
-        }
+        return Expression.Lambda<Func<object, object?>>(access, param).Compile();
+    }
 
-        if (access.Type.IsValueType)
+    private static Expression BuildNullSafePropertyAccess(Expression root, string path) =>
+        BuildNullSafePropertyAccess(root, path.Split('.'), 0);
+
+    private static Expression BuildNullSafePropertyAccess(Expression receiver, string[] propertyNames, int index)
+    {
+        while (true)
         {
-            access = Expression.Convert(access, typeof(object));
-        }
+            if (index == propertyNames.Length)
+            {
+                return Expression.Convert(receiver, typeof(object));
+            }
 
-        return Expression.Lambda<Func<object, object?>>(access, param).Compile();
+            if (receiver.Type.IsValueType && Nullable.GetUnderlyingType(receiver.Type) is null)
+            {
+                receiver = Expression.PropertyOrField(receiver, propertyNames[index++]);
+                continue;
+            }
+
+            ParameterExpression receiverValue = Expression.Variable(receiver.Type, $"segment{index}");
+            return Expression.Block([receiverValue],
+                Expression.Assign(receiverValue, receiver),
+                Expression.Condition(Expression.Equal(receiverValue, Expression.Constant(null, receiver.Type)),
+                    Expression.Constant(AvaloniaProperty.UnsetValue, typeof(object)),
+                    BuildNullSafePropertyAccess(Expression.PropertyOrField(receiverValue, propertyNames[index]), propertyNames, index + 1)));
+        }
     }
 
     private static StyledElement? FindLogicalAncestorOfType(StyledElement start, Type ancestorType)
@@ -266,11 +283,12 @@ public BindingEvaluator(StyledElement anchor, Type dataContextType)
                     && b.Source == AvaloniaProperty.UnsetValue
                     && string.IsNullOrEmpty(b.ElementName)
                     && b.RelativeSource is null => path,
-                CompiledBindingExtension c when c.Converter is null
+                CompiledBinding c when c.Converter is null
                     && c.StringFormat is null
                     && c.FallbackValue == AvaloniaProperty.UnsetValue
                     && c.TargetNullValue == AvaloniaProperty.UnsetValue
                     && c.Source == AvaloniaProperty.UnsetValue => c.Path?.ToString(),
+                // Note: `CompiledBindingExtension` IS a `CompiledBinding`
                 _ => null,
             };
 
@@ -315,23 +333,6 @@ private static bool IsSimpleDotPath(string path)
         return null;
     }
 
-    private static Expression ToStringExpression(Expression value)
-    {
-        if (value.Type == typeof(string))
-        {
-            return Expression.Coalesce(value, Expression.Constant(string.Empty));
-        }
-
-        if (value.Type.IsValueType)
-        {
-            return Expression.Call(value, objectToStringMethod);
-        }
-
-        Expression toString = Expression.Call(value, objectToStringMethod);
-        Expression toStringOrEmpty = Expression.Coalesce(toString, Expression.Constant(string.Empty));
-        return Expression.Condition(Expression.Equal(value, Expression.Constant(null, value.Type)), Expression.Constant(string.Empty), toStringOrEmpty);
-    }
-
     private static bool TryBuildFastPathRawExpression<TDataContext>(BindingBase binding, [NotNullWhen(true)] out Expression<Func<TDataContext, object?>>? expression)
     {
         string? pathString = GetSimplePathWithoutExtras(binding);
@@ -366,6 +367,120 @@ private bool TryBuildFastPathRawGetter(BindingBase binding, [NotNullWhen(true)]
         }
     }
 
+    private static bool TryBuildIntermediateRawExpression<TDataContext>(
+        BindingBase binding,
+        [NotNullWhen(true)] out Expression<Func<TDataContext, object?>>? expression)
+    {
+        if (!TryGetIntermediateRawParts(binding, out string? path, out object? fallbackValue, out object? targetNullValue))
+        {
+            expression = null;
+            return false;
+        }
+
+        try
+        {
+            Func<object, object?> getter = BuildIntermediateRawGetter(path, fallbackValue, targetNullValue, typeof(TDataContext));
+            expression = WrapRawObjectDelegateAsExpression<TDataContext>(getter);
+            return true;
+        }
+        catch
+        {
+            expression = null;
+            return false;
+        }
+    }
+
+    private bool TryBuildIntermediateRawGetter(BindingBase binding, [NotNullWhen(true)] out Func<object, object?>? getter)
+    {
+        if (!TryGetIntermediateRawParts(binding, out string? path, out object? fallbackValue, out object? targetNullValue))
+        {
+            getter = null;
+            return false;
+        }
+
+        try
+        {
+            getter = BuildIntermediateRawGetter(path, fallbackValue, targetNullValue, this.dataContextType);
+            return true;
+        }
+        catch
+        {
+            getter = null;
+            return false;
+        }
+    }
+
+    private static Func<object, object?> BuildIntermediateRawGetter(
+        string path,
+        object? fallbackValue,
+        object? targetNullValue,
+        Type rowType)
+    {
+        Func<object, object?> propertyGetter = BuildPropertyGetter(path, rowType);
+
+        return row =>
+            {
+                try
+                {
+                    object? value = propertyGetter(row);
+                    if (ReferenceEquals(value, AvaloniaProperty.UnsetValue))
+                    {
+                        return fallbackValue;
+                    }
+
+                    if (value is null && !ReferenceEquals(targetNullValue, AvaloniaProperty.UnsetValue))
+                    {
+                        return targetNullValue;
+                    }
+
+                    return value;
+                }
+                catch
+                {
+                    return fallbackValue;
+                }
+            };
+    }
+
+    private static bool TryGetIntermediateRawParts(
+        BindingBase binding,
+        [NotNullWhen(true)] out string? path,
+        out object? fallbackValue,
+        out object? targetNullValue)
+    {
+        switch (binding)
+        {
+            case Binding { Path: { Length: > 0 } bindingPath } b
+                when b.Converter is null
+                     && b.StringFormat is null
+                     && b.Source == AvaloniaProperty.UnsetValue
+                     && string.IsNullOrEmpty(b.ElementName)
+                     && b.RelativeSource is null:
+                path = bindingPath;
+                fallbackValue = b.FallbackValue;
+                targetNullValue = b.TargetNullValue;
+                break;
+
+            // Note: `CompiledBindingExtension` IS a `CompiledBinding`.
+            case CompiledBinding c
+                when c.Converter is null
+                     && c.StringFormat is null
+                     && c.Source == AvaloniaProperty.UnsetValue:
+                path = c.Path?.ToString();
+                fallbackValue = c.FallbackValue;
+                targetNullValue = c.TargetNullValue;
+                break;
+
+            default:
+                path = null;
+                fallbackValue = null;
+                targetNullValue = null;
+                return false;
+        }
+
+        return !string.IsNullOrEmpty(path) && IsSimpleDotPath(path);
+    }
+
     private static bool TryBuildIntermediateExpression<TDataContext>(BindingBase binding, [NotNullWhen(true)] out Expression<Func<TDataContext, string>>? expression)
     {
         if (!TryGetIntermediateParts(binding, out string? path, out object? source, out IValueConverter? converter, out object? converterParameter,
@@ -416,6 +531,11 @@ private static Func<object, string> BuildIntermediateGetter(
                 {
                     object? value = propertyGetter(source ?? row);
 
+                    if (value == AvaloniaProperty.UnsetValue)
+                    {
+                        return fallbackString ?? string.Empty;
+                    }
+
                     if (converter is not null)
                     {
                         value = converter.Convert(value, typeof(string), converterParameter, culture);
@@ -464,7 +584,8 @@ private static bool TryGetIntermediateParts(
                 targetNullValue = b.TargetNullValue == AvaloniaProperty.UnsetValue ? null : b.TargetNullValue;
                 return true;
 
-            case CompiledBindingExtension c:
+            case CompiledBinding c:
+            {
                 string? pathString = c.Path?.ToString();
                 if (string.IsNullOrEmpty(pathString) || !IsSimpleDotPath(pathString))
                 {
@@ -480,6 +601,9 @@ private static bool TryGetIntermediateParts(
                 fallbackValue = c.FallbackValue == AvaloniaProperty.UnsetValue ? null : c.FallbackValue;
                 targetNullValue = c.TargetNullValue == AvaloniaProperty.UnsetValue ? null : c.TargetNullValue;
                 return true;
+            }
+            
+            // Note: `CompiledBindingExtension` IS a `CompiledBinding`
         }
 
         path = null;
@@ -521,7 +645,9 @@ private bool TryGetSimpleBindingGetter(BindingBase binding, [NotNullWhen(true)]
         try
         {
             Func<object, object?> rawGetter = BuildPropertyGetter(pathString, this.dataContextType);
-            getter = row => rawGetter(row) is { } value ? value as string ?? value.ToString() ?? string.Empty : string.Empty;
+            getter = row => rawGetter(row) is { } value && value != AvaloniaProperty.UnsetValue
+                ? value as string ?? value.ToString() ?? string.Empty
+                : string.Empty;
             return true;
         }
         catch
@@ -538,6 +664,13 @@ private static Expression<Func<TDataContext, string>> WrapObjectDelegateAsExpres
         return Expression.Lambda<Func<TDataContext, string>>(body, rowParameter);
     }
 
+    private static Expression<Func<TDataContext, object?>> WrapRawObjectDelegateAsExpression<TDataContext>(Func<object, object?> getter)
+    {
+        ParameterExpression rowParameter = Expression.Parameter(typeof(TDataContext), "row");
+        Expression body = Expression.Invoke(Expression.Constant(getter), Expression.Convert(rowParameter, typeof(object)));
+        return Expression.Lambda<Func<TDataContext, object?>>(body, rowParameter);
+    }
+
     private Func<object, string> BuildFrameworkDelegatedGetter(BindingBase binding)
     {
         binding = this.RewriteParentBindingIfNeeded(binding);
@@ -584,9 +717,7 @@ private Expression<Func<TDataContext, string>> BuildFrameworkDelegatedGetterExpr
     private Expression<Func<TDataContext, object?>> BuildProxyRawGetterExpression<TDataContext>(BindingBase binding)
     {
         Func<object, object?> getter = this.BuildProxyRawGetter(binding);
-        ParameterExpression rowParameter = Expression.Parameter(typeof(TDataContext), "row");
-        Expression body = Expression.Invoke(Expression.Constant(getter), Expression.Convert(rowParameter, typeof(object)));
-        return Expression.Lambda<Func<TDataContext, object?>>(body, rowParameter);
+        return WrapRawObjectDelegateAsExpression<TDataContext>(getter);
     }
 
     private ParentPathRewrite? GetOrCreatePathRewrite(string rawPath)