Fix build on net4, add some comments, improve readablity

Author: exyi

src/Framework/Framework/Binding/DotvvmProperty.cs

@@ -233,7 +233,7 @@ public bool IsOwnedByCapability(DotvvmCapabilityProperty capability) =>
             return DefaultValue;
         }
 
-        private bool IsSetInHierarchy(DotvvmBindableObject control)
+        private bool IsSetInherited(DotvvmBindableObject control)
         {
             for (var p = control.Parent; p is not null; p = p.Parent)
             {
@@ -255,7 +255,7 @@ public virtual bool IsSet(DotvvmBindableObject control, bool inherit = true)
 
             if (IsValueInherited && inherit)
             {
-                return IsSetInHierarchy(control);
+                return IsSetInherited(control);
             }
 
             return false;

src/Framework/Framework/Binding/DotvvmPropertyId.cs

@@ -1,31 +1,67 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using DotVVM.Framework.Compilation.ControlTree;
+using DotVVM.Framework.Controls;
 
 namespace DotVVM.Framework.Binding
 {
+    /// <summary>
+    /// Represents a unique <see cref="DotvvmProperty"/> ID, used as a key for <see cref="DotvvmPropertyDictionary" />.
+    /// </summary>
+    /// <remarks>
+    /// The ID is a 32-bit unsigned integer, where:
+    /// - the most significant bit indicates whether the ID is of a property group (1) or a classic property (0)
+    /// - the next upper 15 bits are the <see cref="TypeId"/> (for classic properties) or <see cref="GroupId"/> (for property groups)
+    /// - the lower 16 bits are the <see cref="MemberId"/>, ID of the string key for property groups or the ID of the property for classic properties
+    /// - in case of classic properties, the LSB bit of the member ID indicates whether the property has GetValue/SetValue overrides and is not inherited (see <see cref="CanUseFastAccessors"/>)
+    /// </remarks>
     public readonly struct DotvvmPropertyId: IEquatable<DotvvmPropertyId>, IEquatable<uint>, IComparable<DotvvmPropertyId>
     {
+        /// <summary> Numeric representation of the property ID. </summary>
         public readonly uint Id;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public DotvvmPropertyId(uint id)
         {
             Id = id;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public DotvvmPropertyId(ushort typeOrGroupId, ushort memberId)
         {
             Id = ((uint)typeOrGroupId << 16) | memberId;
         }
 
+        /// <summary> Returns true if the property is a <see cref="GroupedDotvvmProperty"/> other type of property. </summary>
         [MemberNotNullWhen(true, nameof(PropertyGroupInstance), nameof(GroupMemberName))]
-        public bool IsPropertyGroup => (int)Id < 0;
-        public ushort TypeId => (ushort)(Id >> 16);
-        public ushort GroupId => (ushort)((Id >> 16) ^ 0x80_00);
-        public ushort MemberId => (ushort)(Id & 0xFFFF);
+        public bool IsPropertyGroup
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (int)Id < 0;
+        }
+        /// <summary> Returns the ID of the property declaring type </summary>
+        public ushort TypeId
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (ushort)(Id >> 16);
+        }
+        /// <summary> Returns the ID of the property group. </summary>
+        public ushort GroupId
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (ushort)((Id >> 16) ^ 0x8000);
+        }
+        /// <summary> Returns the ID of the property member, i.e. property-in-type id for classic properties, or the name ID for property groups. </summary>
+        public ushort MemberId
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (ushort)(Id & 0xFFFF);
+        }
 
-        /// <summary> Returns true if the property does not have GetValue/SetValue overrides and is not inherited. That means it is sufficient  </summary>
+        /// <summary> Returns true if the property does not have GetValue/SetValue overrides and is not inherited. That means it is sufficient to call properties.TryGet instead going through the DotvvmProperty.GetValue dynamic dispatch </summary>
         public bool CanUseFastAccessors
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
                 // properties: we encode this information as the LSB bit of the member ID (i.e. odd/even numbers)
@@ -36,41 +72,75 @@ public bool CanUseFastAccessors
             }
         }
 
-        public bool IsZero => Id == 0;
+        /// <summary> Returns true if the ID is default. This ID is invalid for most purposes and can be used as a sentinel value. </summary>
+        public bool IsZero
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => Id == 0;
+        }
 
+        /// <summary> Returns the <see cref="DotvvmProperty"/> instance for this ID. Note that a new <see cref="GroupedDotvvmProperty"/> might need to be allocated. </summary>
         public DotvvmProperty PropertyInstance => DotvvmPropertyIdAssignment.GetProperty(Id) ?? throw new Exception($"Property with ID {Id} not registered.");
+
+        /// <summary> Returns the <see cref="GroupedDotvvmProperty"/> instance for this ID, or <c>null</c> if the ID is of a classic property. </summary>
+        
         public DotvvmPropertyGroup? PropertyGroupInstance => !IsPropertyGroup ? null : DotvvmPropertyIdAssignment.GetPropertyGroup(GroupId);
+
+        /// <summary> Returns the name (string dictionary key) of the property group member, or <c>null</c> if the ID is of a classic property. </summary>
         public string? GroupMemberName => !IsPropertyGroup ? null : DotvvmPropertyIdAssignment.GetGroupMemberName(MemberId);
 
+        /// <summary> Returns the type of the property. </summary>
         public Type PropertyType => IsPropertyGroup ? PropertyGroupInstance.PropertyType : PropertyInstance.PropertyType;
+
+        /// <summary> Returns the property declaring type. </summary>
         public Type DeclaringType => IsPropertyGroup ? PropertyGroupInstance.DeclaringType : DotvvmPropertyIdAssignment.GetControlType(TypeId);
 
+        /// <summary> Returns the property declaring type. </summary>
+        [MemberNotNullWhen(true, nameof(PropertyGroupInstance), nameof(GroupMemberName))]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool IsInPropertyGroup(ushort id) => (this.Id >> 16) == ((uint)id | 0x80_00u);
 
+        /// <summary> Constucts property ID from a property group name and a name ID. </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static DotvvmPropertyId CreatePropertyGroupId(ushort groupId, ushort memberId) => new DotvvmPropertyId((ushort)(groupId | 0x80_00), memberId);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator DotvvmPropertyId(uint id) => new DotvvmPropertyId(id);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint(DotvvmPropertyId id) => id.Id;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool Equals(DotvvmPropertyId other) => Id == other.Id;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool Equals(uint other) => Id == other;
+
         public override bool Equals(object? obj) => obj is DotvvmPropertyId id && Equals(id);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override int GetHashCode() => (int)Id;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator ==(DotvvmPropertyId left, DotvvmPropertyId right) => left.Equals(right);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator !=(DotvvmPropertyId left, DotvvmPropertyId right) => !left.Equals(right);
 
         public override string ToString()
         {
             if (IsPropertyGroup)
             {
                 var pg = PropertyGroupInstance;
-                return $"[{Id:x8}]{pg.DeclaringType.Name}.{pg.Name}:{GroupMemberName}";
+                return $"[{TypeId:x4}_{MemberId:x4}]{pg.DeclaringType.Name}.{pg.Name}:{GroupMemberName}";
             }
             else
             {
-                return $"[{Id:x8}]{PropertyInstance.FullName}";
+                return $"[{TypeId:x4}_{MemberId:x4}]{PropertyInstance.FullName}";
             }
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int CompareTo(DotvvmPropertyId other) => Id.CompareTo(other.Id);
     }
 }

src/Framework/Framework/Binding/DotvvmPropertyIdAssignment.GroupMembers.cs

@@ -31,6 +31,8 @@ public static ushort TryGetId(ReadOnlySpan<char> attr) =>
                     "data-bind" => data_bind,
                     _ => 0,
                 };
+
+            // TODO
         }
     }
 }

src/Framework/Framework/Binding/DotvvmPropertyIdAssignment.PropertyIds.cs

@@ -67,6 +67,10 @@ public static class PropertyIds
             public const uint TextBox_Enabled = TypeIds.TextBox << 16 | 1;
             /// <seealso cref="TextBox.UpdateTextOnInputProperty" />
             public const uint TextBox_UpdateTextOnInput = TypeIds.TextBox << 16 | 3;
+            /// <seealso cref="RenderSettings.ModeProperty" />
+            public const uint RenderSettings_Mode = TypeIds.RenderSettings << 16 | 1;
+
+            // TODO
         }
     }
 }

src/Framework/Framework/Binding/DotvvmPropertyIdAssignment.TypeIds.cs

@@ -26,6 +26,7 @@ public static class TypeIds
             public const ushort Validation = 14;
             public const ushort ValidationSummary = 15;
             public const ushort Internal = 16;
+            public const ushort RenderSettings = 17;
 
             public static readonly ImmutableArray<(Type type, ushort id)> List = ImmutableArray.Create(
                 (typeof(DotvvmBindableObject), DotvvmBindableObject),
@@ -43,7 +44,8 @@ public static class TypeIds
                 (typeof(Validator), Validator),
                 (typeof(Validation), Validation),
                 (typeof(ValidationSummary), ValidationSummary),
-                (typeof(Internal), Internal)
+                (typeof(Internal), Internal),
+                (typeof(RenderSettings), RenderSettings)
             );
         }
     }

src/Framework/Framework/Binding/DotvvmPropertyIdAssignment.cs

@@ -13,7 +13,7 @@
 namespace DotVVM.Framework.Binding
 {
 
-    static partial class DotvvmPropertyIdAssignment
+    internal static partial class DotvvmPropertyIdAssignment
     {
         /// Type and property group IDs bellow this are reserved for manual ID assignment
         const int RESERVED_CONTROL_TYPES = 256;
@@ -46,6 +46,7 @@ static DotvvmPropertyIdAssignment()
         }
 
 #region Optimized metadata accessors
+        /// <summary> Equivalent to <see cref="DotvvmProperty.IsValueInherited" /> </summary>
         public static bool IsInherited(DotvvmPropertyId propertyId)
         {
             if (propertyId.CanUseFastAccessors)
@@ -54,6 +55,8 @@ public static bool IsInherited(DotvvmPropertyId propertyId)
             return BitmapRead(controls[propertyId.TypeId].inheritedBitmap, propertyId.MemberId);
         }
 
+        /// <summary> Returns if the DotvvmProperty uses standard GetValue/SetValue method and we can avoid the dynamic dispatch </summary>
+        /// <seealso cref="TypeCanUseAnyDirectAccess(Type)" />
         public static bool UsesStandardAccessors(DotvvmPropertyId propertyId)
         {
             if (propertyId.CanUseFastAccessors)
@@ -68,9 +71,10 @@ public static bool UsesStandardAccessors(DotvvmPropertyId propertyId)
             }
         }
 
+        /// <summary> Returns if the given property is of the <see cref="ActiveDotvvmProperty"/> or <see cref="ActiveDotvvmPropertyGroup" /> type </summary>
         public static bool IsActive(DotvvmPropertyId propertyId)
         {
-            Debug.Assert(DotvvmPropertyIdAssignment.GetProperty(propertyId) != null, $"Property {propertyId} not registered.");
+            Debug.Assert(GetProperty(propertyId) != null, $"Property {propertyId} not registered.");
             ulong[] bitmap;
             uint index;
             if (propertyId.IsPropertyGroup)
@@ -85,7 +89,8 @@ public static bool IsActive(DotvvmPropertyId propertyId)
             }
             return BitmapRead(bitmap, index);
         }
-
+        
+        /// <summary> Returns the DotvvmProperty with a given ID, or returns null if no such property exists. New instance of <see cref="GroupedDotvvmProperty"/> might be created. </summary>
         public static DotvvmProperty? GetProperty(DotvvmPropertyId id)
         {
             if (id.IsPropertyGroup)
@@ -111,6 +116,7 @@ public static bool IsActive(DotvvmPropertyId propertyId)
             }
         }
 
+        /// <summary> Returns the <see cref="DotvvmProperty"/> or <see cref="DotvvmPropertyGroup"/> with the given id </summary>
         public static Compilation.IControlAttributeDescriptor? GetPropertyOrPropertyGroup(DotvvmPropertyId id)
         {
             if (id.IsPropertyGroup)
@@ -132,6 +138,7 @@ public static bool IsActive(DotvvmPropertyId propertyId)
             }
         }
 
+        /// <summary> Returns the value of the property or property group. If the property is not set, returns the default value. </summary>
         public static object? GetValueRaw(DotvvmBindableObject obj, DotvvmPropertyId id, bool inherit = true)
         {
             if (id.CanUseFastAccessors)
@@ -148,6 +155,7 @@ public static bool IsActive(DotvvmPropertyId propertyId)
             }
         }
 
+        /// <summary> Returns the value of the property or property group. If the property is not set, returns the default value. </summary>
         public static MarkupOptionsAttribute GetMarkupOptions(DotvvmPropertyId id)
         {
             if (id.IsPropertyGroup)
@@ -164,6 +172,7 @@ public static MarkupOptionsAttribute GetMarkupOptions(DotvvmPropertyId id)
         }
 
         /// <summary> Property or property group has type assignable to IBinding and bindings should not be evaluated in GetValue </summary>
+        /// <seealso cref="DotvvmProperty.IsBindingProperty"/>
         public static bool IsBindingProperty(DotvvmPropertyId id)
         {
             if (id.IsPropertyGroup)
@@ -202,6 +211,7 @@ public static ushort RegisterType(Type type)
 
             return unlikely(type);
 
+            [MethodImpl(MethodImplOptions.NoInlining)]
             static ushort unlikely(Type type)
             {
                 var types = MemoryMarshal.CreateReadOnlySpan(ref type, 1);
@@ -219,7 +229,14 @@ public static void RegisterTypes(ReadOnlySpan<Type> types, Span<ushort> ids)
             {
                 if (controlCounter + types.Length >= controls.Length)
                 {
-                    VolatileResize(ref controls, 1 << (BitOperations.Log2((uint)(controlCounter + types.Length)) + 1));
+#if NET6_0_OR_GREATER
+                    var nextPow2 = 1 << (BitOperations.Log2((uint)(controlCounter + types.Length)) + 1);
+#else
+                    var nextPow2 = types.Length * 2;
+                    while (nextPow2 < controlCounter + types.Length)
+                        nextPow2 *= 2;
+#endif
+                    VolatileResize(ref controls, nextPow2);
                 }
                 for (int i = 0; i < types.Length; i++)
                 {
@@ -247,6 +264,7 @@ public static void RegisterTypes(ReadOnlySpan<Type> types, Span<ushort> ids)
                 }
             }
         }
+
         public static DotvvmPropertyId RegisterProperty(DotvvmProperty property)
         {
             if (property.GetType() == typeof(GroupedDotvvmProperty))
@@ -318,6 +336,7 @@ static void ThrowTooManyException(DotvvmProperty property) =>
         }
 
         private static readonly ConcurrentDictionary<Type, (bool getter, bool setter)> cacheTypeCanUseDirectAccess = new(concurrencyLevel: 1, capacity: 10);
+
         /// <summary> Does the property use the default GetValue/SetValue methods? </summary>
         public static (bool getter, bool setter) TypeCanUseDirectAccess(Type propertyType)
         {
@@ -380,22 +399,9 @@ private static void VolatileResize<T>(ref T[] array, int newSize)
 #endregion Registration
 
 #region Group members
-        private static ushort PredefinedPropertyGroupMemberId(ReadOnlySpan<char> name)
-        {
-            switch (name)
-            {
-                case "class": return GroupMembers.@class;
-                case "id": return GroupMembers.id;
-                case "style": return GroupMembers.style;
-                case "name": return GroupMembers.name;
-                case "data-bind": return GroupMembers.data_bind;
-                default: return 0;
-            }
-        }
-
         public static ushort GetGroupMemberId(string name, bool registerIfNotFound)
         {
-            var id = PredefinedPropertyGroupMemberId(name);
+            var id = GroupMembers.TryGetId(name);
             if (id != 0)
                 return id;
             if (propertyGroupMemberIds.TryGetValue(name, out id))
@@ -444,8 +450,11 @@ static void BitmapSet(ulong[] bitmap, uint index)
         private struct ControlTypeInfo
         {
             public DotvvmProperty?[] properties;
+            /// <summary> Bitmap for <see cref="DotvvmProperty.IsValueInherited" /> </summary>
             public ulong[] inheritedBitmap;
+            /// <summary> Bitmap for <see cref="TypeCanUseAnyDirectAccess(Type)" /> </summary>
             public ulong[] standardBitmap;
+            /// <summary> Bitmap storing if property is <see cref="ActiveDotvvmProperty" /> </summary>
             public ulong[] activeBitmap;
             /// TODO split struct to part used during registration and part at runtime for lookups
             public object locker;