Backported fix 1385

src/Framework/Framework/Binding/BindingProperties.cs

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis;
 using DotVVM.Framework.Binding.Expressions;
 using DotVVM.Framework.Compilation.ControlTree;
+using System.Reflection;
 
 namespace DotVVM.Framework.Binding.Properties
 {
@@ -232,4 +233,6 @@ public sealed record IsNullOrWhitespaceBindingExpression(IBinding Binding);
     public sealed record IsNullOrEmptyBindingExpression(IBinding Binding);
     /// <summary> Contains the same binding as this binding but converted to a string. </summary>
     public sealed record ExpectedAsStringBindingExpression(IBinding Binding);
+    /// <summary> Contains references to the .NET properties referenced in the binding. MainProperty is the property on the root node (modulo conversions and simple expressions). </summary>
+    public sealed record ReferencedViewModelPropertiesBindingProperty(PropertyInfo? MainProperty, PropertyInfo[] OtherProperties, IValueBinding UnwrappedBindingExpression);
 }

src/Framework/Framework/Binding/Expressions/ValueBindingExpression.cs

@@ -36,11 +36,14 @@ public ValueBindingExpression(BindingCompilationService service, IEnumerable<obj
         }
 
         private protected MaybePropValue<KnockoutExpressionBindingProperty> knockoutExpressions;
+        private protected MaybePropValue<ReferencedViewModelPropertiesBindingProperty> referencedPropertyExpressions;
 
         private protected override void StoreProperty(object p)
         {
             if (p is KnockoutExpressionBindingProperty knockoutExpressions)
                 this.knockoutExpressions.SetValue(new(knockoutExpressions));
+            if (p is ReferencedViewModelPropertiesBindingProperty referencedPropertyExpressions)
+                this.referencedPropertyExpressions.SetValue(new(referencedPropertyExpressions));
             else
                 base.StoreProperty(p);
         }
@@ -49,6 +52,8 @@ private protected override void StoreProperty(object p)
         {
             if (type == typeof(KnockoutExpressionBindingProperty))
                 return knockoutExpressions.GetValue(this).GetValue(errorMode, this, type);
+            if (type == typeof(ReferencedViewModelPropertiesBindingProperty))
+                return referencedPropertyExpressions.GetValue(this).GetValue(errorMode, this, type);
             return base.GetProperty(type, errorMode);
         }
 

src/Framework/Framework/Binding/HelperNamespace/Enums.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using DotVVM.Framework.Utils;
 
 namespace DotVVM.Framework.Binding.HelperNamespace
 {
@@ -9,5 +10,15 @@ public static string[] GetNames<TEnum>()
         {
             return Enum.GetNames(typeof(TEnum));
         }
+
+        public static string? ToEnumString<T>(T? instance) where T : struct, Enum
+        {
+            return ReflectionUtils.ToEnumString(instance);
+        }
+
+        public static string ToEnumString<T>(this T instance) where T : struct, Enum
+        {
+            return ReflectionUtils.ToEnumString<T>(instance);
+        }
     }
 }

src/Framework/Framework/Binding/ValueOrBindingExtensions.cs

@@ -74,11 +74,21 @@ public static ValueOrBinding<IList<T>> GetItems<T>(this ValueOrBinding<IBaseGrid
     public static ValueOrBinding<string> AsString<T>(this ValueOrBinding<T> v)
     {
         if (v.BindingOrDefault is IBinding binding)
-            return new ValueOrBinding<string>(
+            return new(
                 binding.GetProperty<ExpectedAsStringBindingExpression>().Binding
             );
+        else if (v.ValueOrDefault is null)
+        {
+            return new("");
+        }
+        else if (typeof(T).IsValueType && typeof(T).UnwrapNullableType().IsEnum)
+        {
+            return new(ReflectionUtils.ToEnumString(typeof(T), v.ValueOrDefault.ToString() ?? ""));
+        }
         else
-            return new ValueOrBinding<string>("" + v.ValueOrDefault);
+        {
+            return new(v.ValueOrDefault.ToString() ?? "");
+        }
     }
     /// <summary> Returns ValueOrBinding with the value of `a is object`. The resulting binding is cached, so it's safe to use this method at runtime. </summary>
     public static ValueOrBinding<bool> NotNull<T>(this ValueOrBinding<T> v) =>

src/Framework/Framework/Compilation/Binding/GeneralBindingPropertyResolvers.cs

@@ -19,6 +19,7 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Collections.Concurrent;
+using DotVVM.Framework.Binding.HelperNamespace;
 
 namespace DotVVM.Framework.Compilation.Binding
 {
@@ -429,5 +430,49 @@ public IsMoreThanZeroBindingProperty IsMoreThanZero(ParsedExpressionBindingPrope
                 Expression.GreaterThan(expr.Expression, Expression.Constant(0))
             ));
         }
+
+        public ReferencedViewModelPropertiesBindingProperty GetReferencedViewModelProperties(IValueBinding binding, ParsedExpressionBindingProperty expression)
+        {
+            var allProperties = new List<PropertyInfo>();
+            var expr = expression.Expression;
+
+            expr.ForEachMember(m => {
+                if (m is PropertyInfo property)
+                {
+                    allProperties.Add(property);
+                }
+            });
+
+            while (true)
+            {
+                // unwrap type conversions, negations, ...
+                if (expr is UnaryExpression unary)
+                    expr = unary.Operand;
+                // unwrap some method invocations
+                else if (expr is MethodCallExpression boxCall && boxCall.Method.DeclaringType == typeof(BoxingUtils))
+                    expr = boxCall.Arguments.First();
+                else if (expr is MethodCallExpression { Method.Name: nameof(DateTimeExtensions.ToBrowserLocalTime) } dtMethodCall && dtMethodCall.Method.DeclaringType == typeof(DateTimeExtensions))
+                    expr = dtMethodCall.Object ?? dtMethodCall.Arguments.First();
+                else if (expr is MethodCallExpression { Method.Name: nameof(object.ToString) } toStringMethodCall)
+                    expr = toStringMethodCall.Object ?? toStringMethodCall.Arguments.First();
+                else if (expr is MethodCallExpression { Method.Name: nameof(Enums.ToEnumString) } toEnumStringMethodCall && toEnumStringMethodCall.Method.DeclaringType == typeof(Enums))
+                    expr = toEnumStringMethodCall.Object ?? toEnumStringMethodCall.Arguments.First();
+                // unwrap binary operation with a constant
+                else if (expr is BinaryExpression { Right.NodeType: ExpressionType.Constant } binaryLeft)
+                    expr = binaryLeft.Left;
+                else if (expr is BinaryExpression { Left.NodeType: ExpressionType.Constant } binaryRight)
+                    expr = binaryRight.Right;
+                else
+                    break;
+            }
+            var mainProperty = (expr as MemberExpression)?.Member as PropertyInfo;
+            var unwrappedBinding = binding.DeriveBinding(expr);
+
+            return new(
+                mainProperty,
+                allProperties.ToArray(),
+                unwrappedBinding
+            );
+        }
     }
 }

src/Framework/Framework/Compilation/Binding/TypeConversions.cs

@@ -10,6 +10,7 @@
 using DotVVM.Framework.Compilation.Javascript.Ast;
 using DotVVM.Framework.Compilation.ControlTree.Resolved;
 using DotVVM.Framework.Binding;
+using DotVVM.Framework.Binding.HelperNamespace;
 
 namespace DotVVM.Framework.Compilation.Binding
 {
@@ -189,6 +190,10 @@ public static bool IsStringConversionAllowed(Type fromType)
 
         public static Expression? ToStringConversion(Expression src)
         {
+            if (src.Type.UnwrapNullableType().IsEnum)
+            {
+                return Expression.Call(typeof(Enums), "ToEnumString", new [] { src.Type.UnwrapNullableType() }, src);
+            }
             var toStringMethod = src.Type.GetMethod("ToString", Type.EmptyTypes);
             if (toStringMethod?.DeclaringType == typeof(object))
                 toStringMethod = null;

src/Framework/Framework/Compilation/Javascript/JavascriptTranslatableMethodCollection.cs

@@ -203,6 +203,9 @@ private void AddDefaultToStringTranslations()
         {
             AddMethodTranslator(typeof(object), "ToString", new PrimitiveToStringTranslator(), 0);
             AddMethodTranslator(typeof(Convert), "ToString", new PrimitiveToStringTranslator(), 1, true);
+            AddMethodTranslator(typeof(Enums), "ToEnumString", parameterCount: 1, translator: new GenericMethodCompiler(
+                args => args[1]
+            ));
 
             AddMethodTranslator(typeof(DateTime).GetMethod("ToString", Type.EmptyTypes), new GenericMethodCompiler(
                 args => new JsIdentifierExpression("dotvvm").Member("globalize").Member("bindingDateToString")

src/Framework/Framework/Controls/HtmlGenericControl.cs

@@ -10,6 +10,7 @@
 using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
+using FastExpressionCompiler;
 
 namespace DotVVM.Framework.Controls
 {
@@ -368,25 +369,27 @@ private void AddHtmlAttribute(IHtmlWriter writer, string name, object? value)
             }
             else if (value is Enum enumValue)
             {
-                writer.AddAttribute(name, enumValue.ToEnumString());
+                writer.AddAttribute(name, ReflectionUtils.ToEnumString(enumValue.GetType(), enumValue.ToString()));
             }
-            else if (value is Guid)
-            {
-                writer.AddAttribute(name, value.ToString());
-            }
-            else if (ReflectionUtils.IsNumericType(value.GetType()))
-            {
-                writer.AddAttribute(name, Convert.ToString(value, CultureInfo.InvariantCulture));
-            }
-            else
-            {
+        }
+
+        private static string AttributeValueToString(object? value) =>
+            value switch {
+                null => "",
+                string str => str,
+                Enum enumValue => ReflectionUtils.ToEnumString(enumValue.GetType(), enumValue.ToString()),
+                Guid guid => guid.ToString(),
+                _ when ReflectionUtils.IsNumericType(value.GetType()) => Convert.ToString(value, CultureInfo.InvariantCulture) ?? "",
+                System.Collections.IEnumerable =>
+                    throw new NotSupportedException($"Attribute value of type '{value.GetType().ToCode(stripNamespace: true)}' is not supported. Consider concatenating the values into a string or use the HtmlGenericControl.AttributeList if you need to pass multiple values."),
+                _ =>
+
                 // DateTime and related are not supported here intentionally.
                 // It is not clear in which format it should be rendered - on some places, the HTML specs requires just yyyy-MM-dd,
                 // but in case of Web Components, the users may want to pass the whole date, or use a specific format
 
-                throw new NotSupportedException($"Attribute value of type '{value.GetType().FullName}' is not supported. Please convert the value to string, e. g. by using ToString()");
-            }
-        }
+                throw new NotSupportedException($"Attribute value of type '{value.GetType().FullName}' is not supported. Please convert the value to string, e. g. by using ToString()")
+            };
 
         private void AddHtmlAttributesToRender(ref RenderState r, IHtmlWriter writer)
         {

src/Framework/Framework/Controls/KnockoutHelper.cs

@@ -25,11 +25,7 @@ public static class KnockoutHelper
             var expression = control.GetValueBinding(property);
             if (expression != null && (!control.RenderOnServer || renderEvenInServerRenderingMode))
             {
-                writer.AddKnockoutDataBind(name, expression.GetKnockoutBindingExpression(control));
-                if (valueUpdate != null)
-                {
-                    writer.AddKnockoutDataBind("valueUpdate", $"'{valueUpdate}'");
-                }
+                writer.AddKnockoutDataBind(name, control, expression, valueUpdate);
             }
             else
             {
@@ -38,6 +34,18 @@ public static class KnockoutHelper
             }
         }
 
+        /// <summary>
+        /// Adds the data-bind attribute to the next HTML element that is being rendered.
+        /// </summary>
+        public static void AddKnockoutDataBind(this IHtmlWriter writer, string name, DotvvmBindableObject control, IValueBinding expression, string? valueUpdate = null)
+        {
+            writer.AddKnockoutDataBind(name, expression.GetKnockoutBindingExpression(control));
+            if (valueUpdate != null)
+            {
+                writer.AddKnockoutDataBind("valueUpdate", $"'{valueUpdate}'");
+            }
+        }
+
         [Obsolete("Use the AddKnockoutDataBind(this IHtmlWriter writer, string name, IValueBinding valueBinding, DotvvmControl control) or AddKnockoutDataBind(this IHtmlWriter writer, string name, string expression) overload")]
         public static void AddKnockoutDataBind(this IHtmlWriter writer, string name, IValueBinding valueBinding)
         {

src/Framework/Framework/Controls/Validator.cs

@@ -9,6 +9,9 @@
 using DotVVM.Framework.Binding.Expressions;
 using Microsoft.Extensions.DependencyInjection;
 using DotVVM.Framework.Configuration;
+using DotVVM.Framework.Binding.Properties;
+using DotVVM.Framework.Compilation.Binding;
+using System.Linq.Expressions;
 
 namespace DotVVM.Framework.Controls
 {
@@ -83,7 +86,21 @@ public class Validator : HtmlGenericControl
 
         private static void AddValidatedValue(IHtmlWriter writer, IDotvvmRequestContext context, DotvvmProperty prop, DotvvmControl control)
         {
-            writer.AddKnockoutDataBind("dotvvm-validation", control, ValueProperty, renderEvenInServerRenderingMode: true);
+            const string validationDataBindName = "dotvvm-validation";
+
+            var binding = control.GetValueBinding(ValueProperty);
+            if (binding is not null)
+            {
+                var referencedPropertyExpressions = binding.GetProperty<ReferencedViewModelPropertiesBindingProperty>();
+                var unwrappedPropertyExpression = referencedPropertyExpressions.UnwrappedBindingExpression;
+
+                // We were able to unwrap the the provided expression
+                writer.AddKnockoutDataBind(validationDataBindName, control, unwrappedPropertyExpression);
+            }
+            else
+            {
+                throw new DotvvmControlException($"Could not resolve {nameof(ValueProperty)} to a valid value binding.");
+            }
 
             // render options
             var bindingGroup = new KnockoutBindingGroup();

src/Framework/Framework/Utils/ReflectionUtils.cs

@@ -17,7 +17,10 @@
 using System.Runtime.Serialization;
 using System.Threading.Tasks;
 using DotVVM.Framework.Binding;
+using DotVVM.Framework.Configuration;
 using FastExpressionCompiler;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using RecordExceptions;
 
 namespace DotVVM.Framework.Utils
@@ -472,10 +475,18 @@ public static string GetTypeHash(this Type type)
             member is TypeInfo type ? type.AsType() :
             throw new NotImplementedException($"Could not get return type of member {member.GetType().FullName}");
 
-        public static string ToEnumString<T>(this T instance) where T : Enum
+        [return: NotNullIfNotNull("instance")]
+        public static string? ToEnumString<T>(T? instance) where T : struct, Enum
         {
-            return ToEnumString(instance.GetType(), instance.ToString());
+            if (instance == null)
+                return null;
+
+            var name = instance.ToString()!;
+            if (!EnumInfo<T>.HasEnumMemberField)
+                return name;
+            return ToEnumString(typeof(T), name);
         }
+
         public static string ToEnumString(Type enumType, string name)
         {
             var field = enumType.GetField(name);
@@ -490,6 +501,23 @@ public static string ToEnumString(Type enumType, string name)
             return name;
         }
 
+        internal static class EnumInfo<T> where T: struct, Enum
+        {
+            internal static readonly bool HasEnumMemberField;
+
+            static EnumInfo()
+            {
+                foreach (var field in typeof(T).GetFields(BindingFlags.Public | BindingFlags.Static))
+                {
+                    if (field.IsDefined(typeof(EnumMemberAttribute), false))
+                    {
+                        HasEnumMemberField = true;
+                        break;
+                    }
+                }
+            }
+        }
+
         public static Type GetDelegateType(MethodInfo methodInfo)
         {
             return Expression.GetDelegateType(methodInfo.GetParameters().Select(a => a.ParameterType).Append(methodInfo.ReturnType).ToArray());

src/Samples/Common/DotVVM.Samples.Common.csproj

@@ -98,6 +98,7 @@
     <None Remove="Views\FeatureSamples\Serialization\EnumSerializationCoercion.dothtml" />
     <None Remove="Views\FeatureSamples\Serialization\SerializationDateTimeOffset.dothtml" />
     <None Remove="Views\FeatureSamples\StringInterpolation\StringInterpolation.dothtml" />
+    <None Remove="Views\FeatureSamples\Validation\ValidatorValueComplexExpressions.dothtml" />
     <None Remove="Views\FeatureSamples\ViewModules\Incrementer.dotcontrol" />
     <None Remove="Views\FeatureSamples\ViewModules\IncrementerInRepeater.dothtml" />
     <None Remove="Views\FeatureSamples\ViewModules\InnerModuleControl.dotcontrol" />

src/Samples/Common/ViewModels/FeatureSamples/Validation/ValidatorValueComplexExpressionsViewModel.cs

@@ -0,0 +1,29 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using DotVVM.Framework.ViewModel;
+
+namespace DotVVM.Samples.Common.ViewModels.FeatureSamples.Validation
+{
+    public class ValidatorValueComplexExpressionsViewModel : DotvvmViewModelBase
+    {
+        [Required]
+        public DateTime DateTime { get; set; }
+
+        public TestDto[] Collection { get; set; } = new[]
+        {
+            new TestDto() { Id = 1, Description = "DateTime is not null", DateTime = DateTime.Now },
+            new TestDto() { Id = 1, Description = "DateTime is null", DateTime = null }
+        };
+    }
+
+    public class TestDto
+    {
+        public int Id { get; set; }
+
+        public string Description { get; set; }
+
+        [Required]
+        public DateTime? DateTime { get; set; }
+    }
+}
+