Merge pull request #1443 from riganti/attribute-uppercase-warning

acizmarik · web-flow · commit 729d215c6b92 · 2022-08-10T12:49:54.000+02:00
Compile time warning for uppercase atrributes (i.e. mistyped properties)
diff --git a/src/Framework/Framework/Binding/DotvvmCapabilityProperty.cs b/src/Framework/Framework/Binding/DotvvmCapabilityProperty.cs
@@ -285,14 +285,11 @@ internal static IControlAttributeDescriptor InitializeArgument(ICustomAttributeP
                     propertyName,
                     unwrappedType,
                     attributeProvider,
-                    boxedDefaultValue
+                    boxedDefaultValue,
+                    declaringCapability: declaringCapability
                 );
+                propertyGroup.AddUsedInCapability(declaringCapability);
 
-                if (declaringCapability is object)
-                {
-                    propertyGroup.OwningCapability = declaringCapability;
-                    propertyGroup.UsedInCapabilities = propertyGroup.UsedInCapabilities.Add(declaringCapability);
-                }
                 return propertyGroup;
             }
             // Control Capability
diff --git a/src/Framework/Framework/Binding/DotvvmProperty.cs b/src/Framework/Framework/Binding/DotvvmProperty.cs
@@ -105,6 +105,8 @@ public string FullName
         public DotvvmCapabilityProperty? OwningCapability { get; internal set; }
         /// <summary> The capabilities which use this property. </summary>
         public ImmutableArray<DotvvmCapabilityProperty> UsedInCapabilities { get; internal set; } = ImmutableArray<DotvvmCapabilityProperty>.Empty;
+        IPropertyDescriptor? IControlAttributeDescriptor.OwningCapability => OwningCapability;
+        IEnumerable<IPropertyDescriptor> IControlAttributeDescriptor.UsedInCapabilities => UsedInCapabilities;
 
 
         internal void AddUsedInCapability(DotvvmCapabilityProperty? p)
diff --git a/src/Framework/Framework/Binding/GroupedDotvvmProperty.cs b/src/Framework/Framework/Binding/GroupedDotvvmProperty.cs
@@ -8,12 +8,14 @@
 
 namespace DotVVM.Framework.Binding
 {
-    public sealed class GroupedDotvvmProperty : DotvvmProperty
+    public sealed class GroupedDotvvmProperty : DotvvmProperty, IGroupedPropertyDescriptor
     {
         public DotvvmPropertyGroup PropertyGroup { get; }
 
         public string GroupMemberName { get; }
 
+        IPropertyGroupDescriptor IGroupedPropertyDescriptor.PropertyGroup => PropertyGroup;
+
         public GroupedDotvvmProperty(string groupMemberName, DotvvmPropertyGroup propertyGroup)
         {
             this.GroupMemberName = groupMemberName;
@@ -30,7 +32,9 @@ public static GroupedDotvvmProperty Create(DotvvmPropertyGroup group, string nam
                 DefaultValue = group.DefaultValue,
                 IsValueInherited = false,
                 Name = propname,
-                ObsoleteAttribute = group.ObsoleteAttribute
+                ObsoleteAttribute = group.ObsoleteAttribute,
+                OwningCapability = group.OwningCapability,
+                UsedInCapabilities = group.UsedInCapabilities
             };
 
             DotvvmProperty.InitializeProperty(prop, group.AttributeProvider);
diff --git a/src/Framework/Framework/Compilation/ControlTree/ControlTreeResolverBase.cs b/src/Framework/Framework/Compilation/ControlTree/ControlTreeResolverBase.cs
@@ -315,6 +315,8 @@ private void ProcessAttribute(IPropertyDescriptor property, DothtmlAttributeNode
                 return;
             }
 
+            ValidateAttribute(property, control, attribute);
+
             // set the property
             if (attribute.ValueNode == null)
             {
@@ -345,15 +347,79 @@ private void ProcessAttribute(IPropertyDescriptor property, DothtmlAttributeNode
             else
             {
                 // hard-coded value in markup
-                if (!property.MarkupOptions.AllowHardCodedValue)
+                var textValue = (DothtmlValueTextNode)attribute.ValueNode;
+
+                try
                 {
-                    attribute.ValueNode.AddError($"The property '{ property.FullName }' cannot contain hard coded value.");
+                    // ConvertValue may fail, we don't want to crash the compiler in that case.
+                    var value = ConvertValue(WebUtility.HtmlDecode(textValue.Text), property.PropertyType);
+                    var propertyValue = treeBuilder.BuildPropertyValue(property, value, attribute);
+
+                    if (!treeBuilder.AddProperty(control, propertyValue, out var error)) attribute.AddError(error);
                 }
+                catch (Exception e)
+                {
+                    textValue.AddError($"The value '{textValue.Text}' could not be converted to {property.PropertyType.FullName}: {e.Message}");
+                }
+            }
+        }
 
-                var textValue = (DothtmlValueTextNode)attribute.ValueNode;
-                var value = ConvertValue(WebUtility.HtmlDecode(textValue.Text), property.PropertyType);
-                var propertyValue = treeBuilder.BuildPropertyValue(property, value, attribute);
-                if (!treeBuilder.AddProperty(control, propertyValue, out var error)) attribute.AddError(error);
+        private void ValidateAttribute(IPropertyDescriptor property, IAbstractControl control, DothtmlAttributeNode attribute)
+        {
+            if (!property.MarkupOptions.AllowHardCodedValue && attribute.ValueNode is not DothtmlValueBindingNode)
+            {
+                var err = $"The property {property.FullName} cannot contain hard coded value.";
+                if (attribute.ValueNode is not null)
+                    attribute.ValueNode.AddError(err);
+                else
+                    attribute.AddError(err);
+                return;
+            }
+
+            if (!property.MarkupOptions.AllowHardCodedValue &&
+                attribute.ValueNode is DothtmlValueBindingNode resourceBinding &&
+                treatBindingAsHardCodedValue.Contains(resourceBinding.BindingNode.Name))
+            {
+                // TODO: next major version - make this error
+                var err = $"The property {property.FullName} cannot contain hardcoded value nor resource bindings. This will be an error in the next major version.";
+                resourceBinding.AddWarning(err);
+                return;
+            }
+
+            if (!property.MarkupOptions.AllowBinding &&
+                attribute.ValueNode is DothtmlValueBindingNode binding &&
+                !treatBindingAsHardCodedValue.Contains(binding.BindingNode.Name))
+            {
+                // stupid edge case, precompiled controls currently don't allow resource bindings, so it's better to not suggest it in the error message
+                var allowsResourceBinding =
+                    control.Metadata.PrecompilationMode <= ControlPrecompilationMode.IfPossibleAndIgnoreExceptions;
+                var resourceBindingHelp =
+                    allowsResourceBinding && property.PropertyType.IsPrimitiveTypeDescriptor() ? " You can use a resource binding instead - the resource will evaluate the expression server-side." : "";
+                var err = $"The property {property.FullName} cannot contain {binding.BindingNode.Name} binding." + resourceBindingHelp;
+                attribute.AddError(err);
+                return;
+            }
+
+            // validate that html attributes names look valid
+            if (property is IGroupedPropertyDescriptor groupedProperty &&
+                property.UsedInCapabilities.Any(c => c.PropertyType.IsEqualTo(typeof(HtmlCapability))))
+            {
+                var pGroup = groupedProperty.PropertyGroup;
+                var name = groupedProperty.GroupMemberName;
+                if (pGroup.Name.EndsWith("Attributes") && name.ToLowerInvariant() != name)
+                {
+                    // properties with at most two typos
+                    var similarNameProperties =
+                        control.Metadata.AllProperties
+                        .Where(p => StringSimilarity.DamerauLevenshteinDistance(p.Name.ToLowerInvariant(), name.ToLowerInvariant()) <= 2)
+                        .Select(p => p.Name)
+                        .ToArray();
+                    var similarPropertyHelp =
+                        similarNameProperties.Any() ? $" Did you mean {string.Join(", ", similarNameProperties)}, or another DotVVM property?" : " Did you intent to use a DotVVM property instead?";
+                    attribute.AttributeNameNode.AddWarning(
+                        $"HTML attribute name '{name}' should not contain uppercase letters." + similarPropertyHelp
+                    );
+                }
             }
         }
 
diff --git a/src/Framework/Framework/Compilation/ControlTree/DotvvmPropertyGroup.cs b/src/Framework/Framework/Compilation/ControlTree/DotvvmPropertyGroup.cs
@@ -41,11 +41,13 @@ public class DotvvmPropertyGroup : IPropertyGroupDescriptor
         private ConcurrentDictionary<string, GroupedDotvvmProperty> generatedProperties = new();
 
         /// <summary> The capability which declared this property. When the property is declared by an capability, it can only be used by this capability. </summary>
-        public DotvvmCapabilityProperty? OwningCapability { get; internal set; }
+        public DotvvmCapabilityProperty? OwningCapability { get; }
+        IPropertyDescriptor? IControlAttributeDescriptor.OwningCapability => OwningCapability;
         /// <summary> The capabilities which use this property. </summary>
-        public ImmutableArray<DotvvmCapabilityProperty> UsedInCapabilities { get; internal set; } = ImmutableArray<DotvvmCapabilityProperty>.Empty;
+        public ImmutableArray<DotvvmCapabilityProperty> UsedInCapabilities { get; private set; } = ImmutableArray<DotvvmCapabilityProperty>.Empty;
+        IEnumerable<IPropertyDescriptor> IControlAttributeDescriptor.UsedInCapabilities => UsedInCapabilities;
 
-        internal DotvvmPropertyGroup(PrefixArray prefixes, Type valueType, Type declaringType, FieldInfo? descriptorField, ICustomAttributeProvider attributeProvider, string name, object? defaultValue)
+        internal DotvvmPropertyGroup(PrefixArray prefixes, Type valueType, Type declaringType, FieldInfo? descriptorField, ICustomAttributeProvider attributeProvider, string name, object? defaultValue, DotvvmCapabilityProperty? owningCapability = null)
         {
             this.DescriptorField = descriptorField;
             this.DeclaringType = declaringType;
@@ -58,6 +60,7 @@ internal DotvvmPropertyGroup(PrefixArray prefixes, Type valueType, Type declarin
             {
                 ValueMerger = (IAttributeValueMerger?)Activator.CreateInstance(MarkupOptions.AttributeValueMerger);
             }
+            this.OwningCapability = owningCapability;
         }
 
         private static (MarkupOptionsAttribute, DataContextChangeAttribute[], DataContextStackManipulationAttribute?, ObsoleteAttribute?)
@@ -72,6 +75,16 @@ private static (MarkupOptionsAttribute, DataContextChangeAttribute[], DataContex
             return (markupOptions, dataContextChange.ToArray(), dataContextManipulation, obsoleteAttribute);
         }
 
+        internal void AddUsedInCapability(DotvvmCapabilityProperty? p)
+        {
+            if (p is object)
+                lock(this)
+                {
+                    if (!UsedInCapabilities.Contains(p))
+                        UsedInCapabilities = UsedInCapabilities.Add(p);
+                }
+        }
+
         IPropertyDescriptor IPropertyGroupDescriptor.GetDotvvmProperty(string name) => GetDotvvmProperty(name);
         public GroupedDotvvmProperty GetDotvvmProperty(string name)
         {
@@ -109,12 +122,12 @@ internal static FieldInfo FindDescriptorField(Type declaringType, string name)
             return field;
         }
 
-        public static DotvvmPropertyGroup Register(Type declaringType, PrefixArray prefixes, string name, Type valueType, ICustomAttributeProvider attributeProvider, object? defaultValue)
+        public static DotvvmPropertyGroup Register(Type declaringType, PrefixArray prefixes, string name, Type valueType, ICustomAttributeProvider attributeProvider, object? defaultValue, DotvvmCapabilityProperty? declaringCapability = null)
         {
             return descriptorDictionary.GetOrAdd((declaringType, name), fullName => {
                 // the field is optional, here
                 var field = declaringType.GetField(name + "GroupDescriptor", BindingFlags.Public | BindingFlags.Static);
-                return new DotvvmPropertyGroup(prefixes, valueType, declaringType, field, attributeProvider, name, defaultValue);
+                return new DotvvmPropertyGroup(prefixes, valueType, declaringType, field, attributeProvider, name, defaultValue, declaringCapability);
             });
         }
 
diff --git a/src/Framework/Framework/Compilation/ControlTree/IControlResolverMetadata.cs b/src/Framework/Framework/Compilation/ControlTree/IControlResolverMetadata.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using DotVVM.Framework.Binding;
+using DotVVM.Framework.Controls;
 
 namespace DotVVM.Framework.Compilation.ControlTree
 {
@@ -29,6 +30,8 @@ public interface IControlResolverMetadata
 		/// </summary>
 		IReadOnlyList<PropertyGroupMatcher> PropertyGroups { get; }
 
+        ControlPrecompilationMode PrecompilationMode { get; }
+
         DataContextChangeAttribute[] DataContextChangeAttributes { get; }
 		DataContextStackManipulationAttribute? DataContextManipulationAttribute { get; }
 	}
diff --git a/src/Framework/Framework/Compilation/ControlTree/IPropertyDescriptor.cs b/src/Framework/Framework/Compilation/ControlTree/IPropertyDescriptor.cs
@@ -8,4 +8,10 @@ public interface IPropertyDescriptor: IControlAttributeDescriptor
         bool IsBindingProperty { get; }
         string FullName { get; }
     }
+
+    public interface IGroupedPropertyDescriptor: IPropertyDescriptor
+    {
+        string GroupMemberName { get; }
+        IPropertyGroupDescriptor PropertyGroup { get; }
+    }
 }
diff --git a/src/Framework/Framework/Compilation/ControlTree/ITypeDescriptor.cs b/src/Framework/Framework/Compilation/ControlTree/ITypeDescriptor.cs
@@ -1,3 +1,4 @@
+using System;
 using DotVVM.Framework.Controls;
 
 namespace DotVVM.Framework.Compilation.ControlTree
@@ -19,6 +20,7 @@ public interface ITypeDescriptor
         ControlMarkupOptionsAttribute? GetControlMarkupOptionsAttribute();
 
         bool IsEqualTo(ITypeDescriptor other);
+        bool IsEqualTo(Type other);
 
         ITypeDescriptor? TryGetArrayElementOrIEnumerableType();
 
diff --git a/src/Framework/Framework/Compilation/ControlTree/Resolved/ResolvedTypeDescriptor.cs b/src/Framework/Framework/Compilation/ControlTree/Resolved/ResolvedTypeDescriptor.cs
@@ -44,11 +44,25 @@ public bool IsAssignableFrom(ITypeDescriptor typeDescriptor)
             return Type.GetCustomAttribute<ControlMarkupOptionsAttribute>();
         }
 
+        public bool IsEqualTo(Type other)
+        {
+            return this.Type == other;
+        }
         public bool IsEqualTo(ITypeDescriptor other)
         {
+            if (other is ResolvedTypeDescriptor { Type: var otherType })
+                return this.IsEqualTo(otherType);
             return Name == other.Name && Namespace == other.Namespace && Assembly == other.Assembly;
         }
 
+        public override bool Equals(object? obj) =>
+            obj is null ? false :
+            obj is ResolvedTypeDescriptor { Type: var otherType } ? IsEqualTo(otherType) :
+            obj is Type otherType2 ? IsEqualTo(otherType2) :
+            obj is ITypeDescriptor typeD ? IsEqualTo(typeD) :
+            false;
+        public override int GetHashCode() => Type.GetHashCode();
+
         public ITypeDescriptor? TryGetArrayElementOrIEnumerableType()
         {
             // handle array
diff --git a/src/Framework/Framework/Compilation/IControlAttributeDescriptor.cs b/src/Framework/Framework/Compilation/IControlAttributeDescriptor.cs
@@ -19,5 +19,8 @@ public interface IControlAttributeDescriptor
         ObsoleteAttribute? ObsoleteAttribute { get; }
         ITypeDescriptor DeclaringType { get; }
         ITypeDescriptor PropertyType { get; }
+
+        IPropertyDescriptor? OwningCapability { get; }
+        IEnumerable<IPropertyDescriptor> UsedInCapabilities { get; }
     }
 }
diff --git a/src/Framework/Framework/Utils/StringSimilarity.cs b/src/Framework/Framework/Utils/StringSimilarity.cs
@@ -0,0 +1,48 @@
+using System;
+
+namespace DotVVM.Framework.Utils
+{
+    internal static class StringSimilarity
+    {
+        /// <summary> Edit distance with deletion (Visble), insertion (Visivble), substitution (Visine) and transposition (Visilbe) </summary>
+        public static int DamerauLevenshteinDistance(string a, string b)
+        {
+            // https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance
+
+            if (a.Length * b.Length > 100_000)
+                // avoid comparing long strings
+                return a.Length + b.Length;
+
+            var d = new int[a.Length + 1, b.Length + 1];
+
+            for (var i = 0; i <= a.Length; i++)
+                d[i, 0] = i;
+                
+            for (var j = 0; j <= b.Length; j++)
+                d[0, j] = j;
+            
+            for (var i = 0; i < a.Length; i ++)
+            {
+                for (var j = 0; j < b.Length; j++)
+                {
+                    var substitutionCost = a[i] == b[j] ? 0 : 1;
+                    var deletionCost = 1;
+                    var insertionCost = 1;
+                    d[i+1, j+1] = min(d[i, j+1] + deletionCost,
+                                  d[i+1, j] + insertionCost,
+                                  d[i, j] + substitutionCost);
+                    if (i > 1 && j > 1 && a[i] == b[j-1] && a[i-1] == b[j])
+                    {
+                        var transpositionCost = 1;
+                        d[i+1, j+1] = min(d[i+1, j+1],
+                                      d[i-1, j-1] + transpositionCost);
+                    }
+                }
+            }
+            return d[a.Length, b.Length];
+        }
+
+        static int min(int a, int b) => Math.Min(a, b);
+        static int min(int a, int b, int c) => min(min(a, b), c);
+    }
+}
diff --git a/src/Tests/Runtime/ControlTree/DefaultControlTreeResolver/DefaultControlTreeResolverTests.cs b/src/Tests/Runtime/ControlTree/DefaultControlTreeResolver/DefaultControlTreeResolverTests.cs
@@ -701,5 +701,26 @@ @viewModel System.Boolean
             Assert.IsFalse(control3[1].DothtmlNode.HasNodeErrors);
             Assert.IsFalse(control3[2].DothtmlNode.HasNodeErrors);
         }
+
+        [TestMethod]
+        public void DefaultViewCompiler_NonExistenPropertyWarning()
+        {
+           var markup = $@"
+@viewModel System.Boolean
+<dot:Button TestProperty=AA Visble={{value: false}} normal-attribute=AA Click={{command: 0}} />
+";
+            var button = ParseSource(markup)
+                .Content.SelectRecursively(c => c.Content)
+                .Single(c => c.Metadata.Type == typeof(Button));
+
+            var elementNode = (DothtmlElementNode)button.DothtmlNode;
+            var attribute1 = elementNode.Attributes.Single(a => a.AttributeName == "TestProperty");
+            var attribute2 = elementNode.Attributes.Single(a => a.AttributeName == "normal-attribute");
+            var attribute3 = elementNode.Attributes.Single(a => a.AttributeName == "Visble");
+
+            Assert.AreEqual(0, attribute2.AttributeNameNode.NodeWarnings.Count(), attribute2.AttributeNameNode.NodeWarnings.StringJoin(", "));
+            Assert.AreEqual("HTML attribute name 'TestProperty' should not contain uppercase letters. Did you intent to use a DotVVM property instead?", attribute1.AttributeNameNode.NodeWarnings.Single());
+            Assert.AreEqual("HTML attribute name 'Visble' should not contain uppercase letters. Did you mean Visible, or another DotVVM property?", attribute3.AttributeNameNode.NodeWarnings.Single());
+        }
     }
 }
diff --git a/src/Tests/Runtime/DotvvmControlErrorsTests.cs b/src/Tests/Runtime/DotvvmControlErrorsTests.cs
@@ -16,7 +16,7 @@ public void DotvvmBindableControl_DataContextSetToHardCodedValue_ThrowsException
             var dotvvmBuilder = CreateControlRenderer(div, new object());
 
             var exc = Assert.ThrowsException<DotvvmCompilationException>(() => dotvvmBuilder());
-            StringAssert.Contains(exc.Message, "The property 'DotvvmBindableObject.DataContext' cannot contain hard coded value");
+            StringAssert.Contains(exc.Message, "The property DotvvmBindableObject.DataContext cannot contain hard coded value");
         }
 
         [TestMethod]
@@ -26,7 +26,7 @@ public void CheckBox_NotAllowedHardcodedValue_ThrowsException()
             var dotvvmBuilder = CreateControlRenderer(checkbox, new object());
 
             var exc = Assert.ThrowsException<DotvvmCompilationException>(() => dotvvmBuilder()); 
-            StringAssert.Contains(exc.Message, "The property 'CheckBox.Checked' cannot contain hard coded value");
+            StringAssert.Contains(exc.Message, "The property CheckBox.Checked cannot contain hard coded value");
         }
 
         [TestMethod]
diff --git a/src/Tests/Runtime/config-tests/ConfigurationSerializationTests.SerializeDefaultConfig.json b/src/Tests/Runtime/config-tests/ConfigurationSerializationTests.SerializeDefaultConfig.json
@@ -1377,18 +1377,15 @@
           "",
           "html:"
         ],
-        "type": "System.Object",
-        "fromCapability": "HtmlCapability"
+        "type": "System.Object"
       },
       "CssClasses": {
         "prefix": "Class-",
-        "type": "System.Boolean",
-        "fromCapability": "HtmlCapability"
+        "type": "System.Boolean"
       },
       "CssStyles": {
         "prefix": "Style-",
-        "type": "System.Object",
-        "fromCapability": "HtmlCapability"
+        "type": "System.Object"
       }
     },
     "DotVVM.Framework.Controls.JsComponent": {

Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,13 @@ public class DotvvmPropertyGroup : IPropertyGroupDescriptor`
`41`	`41`	`private ConcurrentDictionary<string, GroupedDotvvmProperty> generatedProperties = new();`
`42`	`42`
`43`	`43`	`/// <summary> The capability which declared this property. When the property is declared by an capability, it can only be used by this capability. </summary>`
`44`		`- public DotvvmCapabilityProperty? OwningCapability { get; internal set; }`
	`44`	`+ public DotvvmCapabilityProperty? OwningCapability { get; }`
	`45`	`+ IPropertyDescriptor? IControlAttributeDescriptor.OwningCapability => OwningCapability;`
`45`	`46`	`/// <summary> The capabilities which use this property. </summary>`
`46`		`- public ImmutableArray<DotvvmCapabilityProperty> UsedInCapabilities { get; internal set; } = ImmutableArray<DotvvmCapabilityProperty>.Empty;`
	`47`	`+ public ImmutableArray<DotvvmCapabilityProperty> UsedInCapabilities { get; private set; } = ImmutableArray<DotvvmCapabilityProperty>.Empty;`
	`48`	`+ IEnumerable<IPropertyDescriptor> IControlAttributeDescriptor.UsedInCapabilities => UsedInCapabilities;`
`47`	`49`
`48`		`- internal DotvvmPropertyGroup(PrefixArray prefixes, Type valueType, Type declaringType, FieldInfo? descriptorField, ICustomAttributeProvider attributeProvider, string name, object? defaultValue)`
	`50`	`+ internal DotvvmPropertyGroup(PrefixArray prefixes, Type valueType, Type declaringType, FieldInfo? descriptorField, ICustomAttributeProvider attributeProvider, string name, object? defaultValue, DotvvmCapabilityProperty? owningCapability = null)`
`49`	`51`	`{`
`50`	`52`	`this.DescriptorField = descriptorField;`
`51`	`53`	`this.DeclaringType = declaringType;`
`@@ -58,6 +60,7 @@ internal DotvvmPropertyGroup(PrefixArray prefixes, Type valueType, Type declarin`
`58`	`60`	`{`
`59`	`61`	`ValueMerger = (IAttributeValueMerger?)Activator.CreateInstance(MarkupOptions.AttributeValueMerger);`
`60`	`62`	`}`
	`63`	`+ this.OwningCapability = owningCapability;`
`61`	`64`	`}`
`62`	`65`
`63`	`66`	`private static (MarkupOptionsAttribute, DataContextChangeAttribute[], DataContextStackManipulationAttribute?, ObsoleteAttribute?)`
`@@ -72,6 +75,16 @@ private static (MarkupOptionsAttribute, DataContextChangeAttribute[], DataContex`
`72`	`75`	`return (markupOptions, dataContextChange.ToArray(), dataContextManipulation, obsoleteAttribute);`
`73`	`76`	`}`
`74`	`77`
	`78`	`+ internal void AddUsedInCapability(DotvvmCapabilityProperty? p)`
	`79`	`+ {`
	`80`	`+ if (p is object)`
	`81`	`+ lock(this)`
	`82`	`+ {`
	`83`	`+ if (!UsedInCapabilities.Contains(p))`
	`84`	`+ UsedInCapabilities = UsedInCapabilities.Add(p);`
	`85`	`+ }`
	`86`	`+ }`
	`87`	`+`
`75`	`88`	`IPropertyDescriptor IPropertyGroupDescriptor.GetDotvvmProperty(string name) => GetDotvvmProperty(name);`
`76`	`89`	`public GroupedDotvvmProperty GetDotvvmProperty(string name)`
`77`	`90`	`{`
`@@ -109,12 +122,12 @@ internal static FieldInfo FindDescriptorField(Type declaringType, string name)`
`109`	`122`	`return field;`
`110`	`123`	`}`
`111`	`124`
`112`		`- public static DotvvmPropertyGroup Register(Type declaringType, PrefixArray prefixes, string name, Type valueType, ICustomAttributeProvider attributeProvider, object? defaultValue)`
	`125`	`+ public static DotvvmPropertyGroup Register(Type declaringType, PrefixArray prefixes, string name, Type valueType, ICustomAttributeProvider attributeProvider, object? defaultValue, DotvvmCapabilityProperty? declaringCapability = null)`
`113`	`126`	`{`
`114`	`127`	`return descriptorDictionary.GetOrAdd((declaringType, name), fullName => {`
`115`	`128`	`// the field is optional, here`
`116`	`129`	`var field = declaringType.GetField(name + "GroupDescriptor", BindingFlags.Public \| BindingFlags.Static);`
`117`		`- return new DotvvmPropertyGroup(prefixes, valueType, declaringType, field, attributeProvider, name, defaultValue);`
	`130`	`+ return new DotvvmPropertyGroup(prefixes, valueType, declaringType, field, attributeProvider, name, defaultValue, declaringCapability);`
`118`	`131`	`});`
`119`	`132`	`}`
`120`	`133`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Diagnostics.CodeAnalysis;`
`3`	`3`	`using DotVVM.Framework.Binding;`
	`4`	`+using DotVVM.Framework.Controls;`
`4`	`5`
`5`	`6`	`namespace DotVVM.Framework.Compilation.ControlTree`
`6`	`7`	`{`
`@@ -29,6 +30,8 @@ public interface IControlResolverMetadata`
`29`	`30`	`/// </summary>`
`30`	`31`	`IReadOnlyList<PropertyGroupMatcher> PropertyGroups { get; }`
`31`	`32`
	`33`	`+ ControlPrecompilationMode PrecompilationMode { get; }`
	`34`	`+`
`32`	`35`	`DataContextChangeAttribute[] DataContextChangeAttributes { get; }`
`33`	`36`	`DataContextStackManipulationAttribute? DataContextManipulationAttribute { get; }`
`34`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,4 +8,10 @@ public interface IPropertyDescriptor: IControlAttributeDescriptor`
`8`	`8`	`bool IsBindingProperty { get; }`
`9`	`9`	`string FullName { get; }`
`10`	`10`	`}`
	`11`	`+`
	`12`	`+ public interface IGroupedPropertyDescriptor: IPropertyDescriptor`
	`13`	`+ {`
	`14`	`+ string GroupMemberName { get; }`
	`15`	`+ IPropertyGroupDescriptor PropertyGroup { get; }`
	`16`	`+ }`
`11`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,25 @@ public bool IsAssignableFrom(ITypeDescriptor typeDescriptor)`
`44`	`44`	`return Type.GetCustomAttribute<ControlMarkupOptionsAttribute>();`
`45`	`45`	`}`
`46`	`46`
	`47`	`+ public bool IsEqualTo(Type other)`
	`48`	`+ {`
	`49`	`+ return this.Type == other;`
	`50`	`+ }`
`47`	`51`	`public bool IsEqualTo(ITypeDescriptor other)`
`48`	`52`	`{`
	`53`	`+ if (other is ResolvedTypeDescriptor { Type: var otherType })`
	`54`	`+ return this.IsEqualTo(otherType);`
`49`	`55`	`return Name == other.Name && Namespace == other.Namespace && Assembly == other.Assembly;`
`50`	`56`	`}`
`51`	`57`
	`58`	`+ public override bool Equals(object? obj) =>`
	`59`	`+ obj is null ? false :`
	`60`	`+ obj is ResolvedTypeDescriptor { Type: var otherType } ? IsEqualTo(otherType) :`
	`61`	`+ obj is Type otherType2 ? IsEqualTo(otherType2) :`
	`62`	`+ obj is ITypeDescriptor typeD ? IsEqualTo(typeD) :`
	`63`	`+ false;`
	`64`	`+ public override int GetHashCode() => Type.GetHashCode();`
	`65`	`+`
`52`	`66`	`public ITypeDescriptor? TryGetArrayElementOrIEnumerableType()`
`53`	`67`	`{`
`54`	`68`	`// handle array`
Original file line number	Diff line number	Diff line change
`@@ -19,5 +19,8 @@ public interface IControlAttributeDescriptor`
`19`	`19`	`ObsoleteAttribute? ObsoleteAttribute { get; }`
`20`	`20`	`ITypeDescriptor DeclaringType { get; }`
`21`	`21`	`ITypeDescriptor PropertyType { get; }`
	`22`	`+`
	`23`	`+ IPropertyDescriptor? OwningCapability { get; }`
	`24`	`+ IEnumerable<IPropertyDescriptor> UsedInCapabilities { get; }`
`22`	`25`	`}`
`23`	`26`	`}`