Merge pull request #1909 from riganti/not-assign-init-only

Disallow asigning to init-only properties in bindings

Author: tomasherceg

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

@@ -58,6 +58,10 @@ public Expression<BindingDelegate> CompileToDelegate(
         {
             var replacementVisitor = new BindingCompiler.ParameterReplacementVisitor(dataContext);
             var expr = replacementVisitor.Visit(expression.Expression);
+            var initOnlyPropertyChecker = binding is IStaticCommandBinding
+                                        ? InitOnlyPropertyCheckingVisitor.InstanceDynamicError // allow this client-side
+                                        : InitOnlyPropertyCheckingVisitor.Instance;
+            expr = initOnlyPropertyChecker.Visit(expr);
             expr = new ExpressionNullPropagationVisitor(e => true).Visit(expr);
             expr = ExpressionUtils.ConvertToObject(expr);
             expr = replacementVisitor.WrapExpression(expr, contextObject: binding);

src/Framework/Framework/Compilation/Binding/InitOnlyPropertyCheckingVisitor.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using DotVVM.Framework.Utils;
+
+namespace DotVVM.Framework.Compilation.Binding
+{
+    /// <summary> Checks that assigned properties have setters without the [IsExternalInit] attribute.
+    ///           <paramref name="staticError"/> specifies if the error should be thrown immediately, or only when actually executed at runtime. </summary>
+    public class InitOnlyPropertyCheckingVisitor(bool staticError = true): ExpressionVisitor
+    {
+        public static InitOnlyPropertyCheckingVisitor Instance { get; } = new InitOnlyPropertyCheckingVisitor(true);
+        public static InitOnlyPropertyCheckingVisitor InstanceDynamicError { get; } = new InitOnlyPropertyCheckingVisitor(false);
+
+        protected override Expression VisitBinary(BinaryExpression node)
+        {
+            if (node is { NodeType: ExpressionType.Assign, Left: MemberExpression { Member: PropertyInfo assignedProperty } } &&
+                assignedProperty.IsInitOnly())
+            {
+                var message = $"Property '{assignedProperty.DeclaringType!.Name}.{assignedProperty.Name}' is init-only and cannot be assigned to in bindings executed server-side. You can only assign to such properties in staticCommand bindings executed on the client.";
+                if (staticError)
+                {
+                    throw new Exception(message);
+                }
+                else
+                {
+                    return Expression.Throw(Expression.New(typeof(Exception).GetConstructor([typeof(string)])!, [Expression.Constant(message)]));
+                }
+            }
+
+            return base.VisitBinary(node);
+        }
+    }
+}

src/Tests/Binding/BindingCompilationTests.cs

@@ -1354,6 +1354,17 @@ public void BindingCompiler_AmbiguousMatches()
             var result = ExecuteBinding("Strings.SomeResource", new[] { new NamespaceImport("DotVVM.Framework.Tests.Ambiguous"), new NamespaceImport("DotVVM.Framework.Tests") }, new TestViewModel());
             Assert.AreEqual("hello", result);
         }
+
+        [TestMethod]
+        public void BindingCompiler_InitOnlyPropertyCannotBeAssigned()
+        {
+            var vm = new TestViewModelWithInitOnlyProperties() { MyProperty = 999 };
+
+            var exception = XAssert.ThrowsAny<Exception>(() => ExecuteBinding("_this.MyProperty = 1", vm));
+            XAssert.Contains("Property 'TestViewModelWithInitOnlyProperties.MyProperty' is init-only", exception.Message);
+
+            Assert.AreEqual(999, vm.MyProperty);
+        }
     }
     public class TestViewModel
     {
@@ -1574,6 +1585,11 @@ public class TestViewModel5
         public int[] Array { get; set; } = new int[] { 1, 2, 3 };
     }
 
+    public class TestViewModelWithInitOnlyProperties
+    {
+        public int MyProperty { get; init; }
+    }
+
     public struct TestStruct
     {
         public int Int { get; set; }

src/Tests/Binding/StaticCommandCompilationTests.cs

@@ -384,6 +384,16 @@ public void StaticCommandCompilation_FailReasonablyOnInvalidMethod()
             Assert.AreEqual("Member 'Int32 GetCharCode(Char)' is not static.", result.GetBaseException().Message);
         }
 
+
+        [TestMethod]
+        public void StaticCommandCompilation_InitOnlyPropertyCanBeAssigned()
+        {
+            // on client, we allow this (we don't support with nor calling constructor, so it would be very annoying without this)
+            var result = CompileBinding("_this.MyProperty = 1", niceMode: true, new[] { typeof(TestViewModelWithInitOnlyProperties) }, typeof(Command));
+            Console.WriteLine(result);
+            AreEqual("{options.viewModel.MyProperty(1);}", result);
+        }
+
         public void AreEqual(string expected, string actual)
         => Assert.AreEqual(RemoveWhitespaces(expected), RemoveWhitespaces(actual));