[release/11.0-preview4] Virtualization AnchorMode with for variable-height support

src/Components/Analyzers/src/DiagnosticDescriptors.cs

@@ -102,4 +102,13 @@ internal static class DiagnosticDescriptors
         DiagnosticSeverity.Warning,
         isEnabledByDefault: true,
         description: CreateLocalizableResourceString(nameof(Resources.UseInvokeVoidAsyncForObjectReturn_Description)));
+
+    public static readonly DiagnosticDescriptor VirtualizeItemsProviderRequiresItemComparer = new(
+        "BL0011",
+        CreateLocalizableResourceString(nameof(Resources.VirtualizeItemsProviderRequiresItemComparer_Title)),
+        CreateLocalizableResourceString(nameof(Resources.VirtualizeItemsProviderRequiresItemComparer_Format)),
+        Usage,
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: CreateLocalizableResourceString(nameof(Resources.VirtualizeItemsProviderRequiresItemComparer_Description)));
 }

src/Components/Analyzers/src/Resources.resx

@@ -210,4 +210,13 @@
   <data name="UseInvokeVoidAsyncForObjectReturn_Title" xml:space="preserve">
     <value>Use InvokeVoidAsync instead of InvokeAsync&lt;object&gt;</value>
   </data>
+  <data name="VirtualizeItemsProviderRequiresItemComparer_Description" xml:space="preserve">
+    <value>Without ItemComparer, the component cannot detect whether items were prepended or appended, causing the viewport to jump when items change dynamically.</value>
+  </data>
+  <data name="VirtualizeItemsProviderRequiresItemComparer_Format" xml:space="preserve">
+    <value>Virtualize uses 'ItemsProvider' without 'ItemComparer'. Set ItemComparer to an IEqualityComparer that identifies items by a unique key.</value>
+  </data>
+  <data name="VirtualizeItemsProviderRequiresItemComparer_Title" xml:space="preserve">
+    <value>Virtualize with ItemsProvider requires ItemComparer</value>
+  </data>
 </root>

src/Components/Analyzers/src/VirtualizeItemComparerAnalyzer.cs

@@ -0,0 +1,141 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+#nullable enable
+
+namespace Microsoft.AspNetCore.Components.Analyzers;
+
+/// <summary>
+/// Analyzer that detects usage of Virtualize with ItemsProvider but without ItemComparer.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class VirtualizeItemComparerAnalyzer : DiagnosticAnalyzer
+{
+    private const string VirtualizeTypeName = "Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize`1";
+    private const string RenderTreeBuilderTypeName = "Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder";
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+        ImmutableArray.Create(DiagnosticDescriptors.VirtualizeItemsProviderRequiresItemComparer);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var virtualizeType = compilationContext.Compilation.GetTypeByMetadataName(VirtualizeTypeName);
+            var renderTreeBuilderType = compilationContext.Compilation.GetTypeByMetadataName(RenderTreeBuilderTypeName);
+
+            if (virtualizeType is null || renderTreeBuilderType is null)
+            {
+                return;
+            }
+
+            compilationContext.RegisterOperationBlockStartAction(blockContext =>
+            {
+                var componentStack = new Stack<ComponentState>();
+                var completedVirtualizeComponents = new List<ComponentState>();
+
+                blockContext.RegisterOperationAction(operationContext =>
+                {
+                    var invocation = (IInvocationOperation)operationContext.Operation;
+                    var targetMethod = invocation.TargetMethod;
+
+                    if (!SymbolEqualityComparer.Default.Equals(targetMethod.ContainingType, renderTreeBuilderType))
+                    {
+                        return;
+                    }
+
+                    switch (targetMethod.Name)
+                    {
+                        case "OpenComponent":
+                            if (targetMethod.IsGenericMethod && targetMethod.TypeArguments.Length == 1)
+                            {
+                                var typeArg = targetMethod.TypeArguments[0];
+                                var originalDef = typeArg is INamedTypeSymbol namedType && namedType.IsGenericType
+                                    ? namedType.OriginalDefinition
+                                    : typeArg;
+
+                                if (SymbolEqualityComparer.Default.Equals(originalDef, virtualizeType))
+                                {
+                                    componentStack.Push(new ComponentState { IsVirtualize = true });
+                                }
+                                else
+                                {
+                                    componentStack.Push(new ComponentState { IsVirtualize = false });
+                                }
+                            }
+                            else
+                            {
+                                componentStack.Push(new ComponentState { IsVirtualize = false });
+                            }
+                            break;
+
+                        case "AddComponentParameter":
+                            if (componentStack.Count > 0 && componentStack.Peek().IsVirtualize)
+                            {
+                                if (invocation.Arguments.Length >= 2)
+                                {
+                                    var nameArg = invocation.Arguments[1];
+                                    if (nameArg.Value.ConstantValue.HasValue &&
+                                        nameArg.Value.ConstantValue.Value is string paramName)
+                                    {
+                                        var state = componentStack.Peek();
+                                        if (paramName == "ItemsProvider")
+                                        {
+                                            state.HasItemsProvider = true;
+                                            state.ItemsProviderLocation = invocation.Syntax.GetLocation();
+                                        }
+                                        else if (paramName == "ItemComparer")
+                                        {
+                                            state.HasItemComparer = true;
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+
+                        case "CloseComponent":
+                            if (componentStack.Count > 0)
+                            {
+                                var state = componentStack.Pop();
+                                if (state.IsVirtualize)
+                                {
+                                    completedVirtualizeComponents.Add(state);
+                                }
+                            }
+                            break;
+                    }
+                }, OperationKind.Invocation);
+
+                blockContext.RegisterOperationBlockEndAction(endContext =>
+                {
+                    foreach (var state in completedVirtualizeComponents)
+                    {
+                        if (state.HasItemsProvider && !state.HasItemComparer && state.ItemsProviderLocation != null)
+                        {
+                            endContext.ReportDiagnostic(Diagnostic.Create(
+                                DiagnosticDescriptors.VirtualizeItemsProviderRequiresItemComparer,
+                                state.ItemsProviderLocation));
+                        }
+                    }
+                });
+            });
+        });
+    }
+
+    private sealed class ComponentState
+    {
+        public bool IsVirtualize { get; set; }
+        public bool HasItemsProvider { get; set; }
+        public bool HasItemComparer { get; set; }
+        public Location? ItemsProviderLocation { get; set; }
+    }
+}

src/Components/Analyzers/test/VirtualizeItemComparerAnalyzerTest.cs

@@ -0,0 +1,127 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using TestHelper;
+
+namespace Microsoft.AspNetCore.Components.Analyzers.Test;
+
+public class VirtualizeItemComparerAnalyzerTest : DiagnosticVerifier
+{
+    protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer() => new VirtualizeItemComparerAnalyzer();
+
+    private static readonly string VirtualizeDeclarations = @"
+    namespace Microsoft.AspNetCore.Components.Rendering
+    {
+        public class RenderTreeBuilder
+        {
+            public void OpenComponent<TComponent>(int sequence) where TComponent : IComponent { }
+            public void AddComponentParameter(int sequence, string name, object value) { }
+            public void CloseComponent() { }
+        }
+    }
+
+    namespace Microsoft.AspNetCore.Components
+    {
+        public interface IComponent { }
+    }
+
+    namespace Microsoft.AspNetCore.Components.Web.Virtualization
+    {
+        public class Virtualize<TItem> : Microsoft.AspNetCore.Components.IComponent
+        {
+            public object ItemsProvider { get; set; }
+            public object Items { get; set; }
+            public object ItemComparer { get; set; }
+            public float ItemSize { get; set; }
+        }
+
+        public delegate System.Threading.Tasks.ValueTask<ItemsProviderResult<TItem>> ItemsProviderDelegate<TItem>(ItemsProviderRequest request);
+
+        public struct ItemsProviderRequest { }
+        public struct ItemsProviderResult<TItem> { }
+    }
+";
+
+    [Fact]
+    public void ItemsProviderWithoutItemComparer_ReportsDiagnostic()
+    {
+        var test = @"
+    namespace ConsoleApplication1
+    {
+        using Microsoft.AspNetCore.Components.Rendering;
+        using Microsoft.AspNetCore.Components.Web.Virtualization;
+
+        class TestComponent
+        {
+            void BuildRenderTree(RenderTreeBuilder __builder)
+            {
+                __builder.OpenComponent<Virtualize<string>>(0);
+                __builder.AddComponentParameter(1, ""ItemsProvider"", (object)null);
+                __builder.AddComponentParameter(2, ""ItemSize"", (object)50f);
+                __builder.CloseComponent();
+            }
+        }
+    }" + VirtualizeDeclarations;
+
+        VerifyCSharpDiagnostic(test,
+            new DiagnosticResult
+            {
+                Id = DiagnosticDescriptors.VirtualizeItemsProviderRequiresItemComparer.Id,
+                Message = "Virtualize uses 'ItemsProvider' without 'ItemComparer'. Set ItemComparer to an IEqualityComparer that identifies items by a unique key.",
+                Severity = DiagnosticSeverity.Warning,
+                Locations = new[]
+                {
+                    new DiagnosticResultLocation("Test0.cs", 12, 17)
+                }
+            });
+    }
+
+    [Fact]
+    public void ItemsProviderWithItemComparer_NoDiagnostic()
+    {
+        var test = @"
+    namespace ConsoleApplication1
+    {
+        using Microsoft.AspNetCore.Components.Rendering;
+        using Microsoft.AspNetCore.Components.Web.Virtualization;
+
+        class TestComponent
+        {
+            void BuildRenderTree(RenderTreeBuilder __builder)
+            {
+                __builder.OpenComponent<Virtualize<string>>(0);
+                __builder.AddComponentParameter(1, ""ItemsProvider"", (object)null);
+                __builder.AddComponentParameter(2, ""ItemComparer"", (object)null);
+                __builder.CloseComponent();
+            }
+        }
+    }" + VirtualizeDeclarations;
+
+        VerifyCSharpDiagnostic(test);
+    }
+
+    [Fact]
+    public void ItemsCollectionWithoutItemComparer_NoDiagnostic()
+    {
+        var test = @"
+    namespace ConsoleApplication1
+    {
+        using Microsoft.AspNetCore.Components.Rendering;
+        using Microsoft.AspNetCore.Components.Web.Virtualization;
+
+        class TestComponent
+        {
+            void BuildRenderTree(RenderTreeBuilder __builder)
+            {
+                __builder.OpenComponent<Virtualize<string>>(0);
+                __builder.AddComponentParameter(1, ""Items"", (object)null);
+                __builder.CloseComponent();
+            }
+        }
+    }" + VirtualizeDeclarations;
+
+        VerifyCSharpDiagnostic(test);
+    }
+}