Replace @Bind with bind-...

This change introduces a 'tag helper' that replaces @Bind with custom
code generation that accomplishes roughly the same thing.

This feature lights up by dynamically generating tag helpers that are
visible to tooling and affect the code generation based on:
- pattern recognition of component properties
- attributes that create definitions for elements
- a 'fallback' case for elements

'bind' also supports format strings (currently only for DateTime) via
a separate attribute.

This change introduces the basic framework for bind and tooling support.
We know that we'll have to do more work to define the set of default
'bind' cases for the DOM and to flesh out the conversion/formatting
infrastructure.

This change gets us far enough to replace all of the cases we currently
have tests for :) with the new features. The old @Bind technique still
works for now.

Examples:

@* bind an input element to an expression *@
<input bind="@SelectedDate" format="mm/dd/yyyy" />
@functions {
    public DateTime SelectedDate { get; set; }
}

@* bind an arbitrary expression to an arbitrary set of attributes *@
<div bind-myvalue-myevent="@SomeExpression">...</div>

@* write a component that supports bind *@

@* in Counter.cshtml *@
<div>...html omitted for brevity...</div>
@functions {
    public int Value { get; set; } = 1;
    public Action<int> ValueChanged { get; set; }
}

@* in another file *@
<Counter bind-Value="@CurrentValue" />
@functions {
    public int CurrentValue { get; set; }
}

Author: rynowak

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/BindLoweringPass.cs

@@ -7,6 +7,8 @@ namespace Microsoft.AspNetCore.Blazor.Razor
     // Keep these in sync with the actual definitions
     internal static class BlazorApi
     {
+        public static readonly string AssemblyName = "Microsoft.AspNetCore.Blazor";
+
         public static class BlazorComponent
         {
             public static readonly string FullTypeName = "Microsoft.AspNetCore.Blazor.Components.BlazorComponent";
@@ -64,13 +66,27 @@ public static class RouteAttribute
             public static readonly string FullTypeName = "Microsoft.AspNetCore.Blazor.Components.RouteAttribute";
         }
 
+        public static class BindElementAttribute
+        {
+            public static readonly string FullTypeName = "Microsoft.AspNetCore.Blazor.Components.BindElementAttribute";
+        }
+
+        public static class BindInputElementAttribute
+        {
+            public static readonly string FullTypeName = "Microsoft.AspNetCore.Blazor.Components.BindInputElementAttribute";
+        }
+
         public static class BindMethods
         {
+            public static readonly string FullTypeName = "Microsoft.AspNetCore.Blazor.Components.BindMethods";
+
             public static readonly string GetValue = "Microsoft.AspNetCore.Blazor.Components.BindMethods.GetValue";
 
             public static readonly string SetValue = "Microsoft.AspNetCore.Blazor.Components.BindMethods.SetValue";
+
+            public static readonly string SetValueHandler = "Microsoft.AspNetCore.Blazor.Components.BindMethods.SetValueHandler";
         }
-        
+
         public static class UIEventHandler
         {
             public static readonly string FullTypeName = "Microsoft.AspNetCore.Blazor.UIEventHandler";

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/BindTagHelperDescriptorProvider.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -88,5 +89,21 @@ public static RazorDiagnostic CreatePageDirective_MustSpecifyRoute(SourceSpan? s
             var diagnostic = RazorDiagnostic.Create(PageDirective_MustSpecifyRoute, source ?? SourceSpan.Undefined);
             return diagnostic;
         }
+
+        public static readonly RazorDiagnosticDescriptor BindAttribute_Duplicates =
+            new RazorDiagnosticDescriptor(
+            "BL9989",
+            () => "The attribute '{0}' was matched by multiple bind attributes. Duplicates:{1}",
+            RazorDiagnosticSeverity.Error);
+
+        public static RazorDiagnostic CreateBindAttribute_Duplicates(SourceSpan? source, string attribute, ComponentAttributeExtensionNode[] attributes)
+        {
+            var diagnostic = RazorDiagnostic.Create(
+                BindAttribute_Duplicates,
+                source ?? SourceSpan.Undefined,
+                attribute,
+                Environment.NewLine + string.Join(Environment.NewLine, attributes.Select(p => p.TagHelper.DisplayName)));
+            return diagnostic;
+        }
     }
 }

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/BlazorApi.cs

@@ -65,12 +65,17 @@ public static void Register(RazorProjectEngineBuilder builder)
 
             builder.Features.Add(new ConfigureBlazorCodeGenerationOptions());
 
+            // Implementation of components
             builder.Features.Add(new ComponentDocumentClassifierPass());
             builder.Features.Add(new ComplexAttributeContentPass());
             builder.Features.Add(new ComponentLoweringPass());
-
             builder.Features.Add(new ComponentTagHelperDescriptorProvider());
 
+            // Implementation of bind
+            builder.Features.Add(new BindLoweringPass());
+            builder.Features.Add(new BindTagHelperDescriptorProvider());
+            builder.Features.Add(new OrphanTagHelperLoweringPass());
+
             if (builder.Configuration.ConfigurationName == DeclarationConfiguration.ConfigurationName)
             {
                 // This is for 'declaration only' processing. We don't want to try and emit any method bodies during

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/BlazorDiagnosticFactory.cs

@@ -0,0 +1,39 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.Blazor.Razor
+{
+    // Metadata used for Blazor's interations with the tag helper system
+    internal static class BlazorMetadata
+    {
+        // There's a bug in the 15.7 preview 1 Razor that prevents 'Kind' from being serialized
+        // this affects both tooling and build. For now our workaround is to ignore 'Kind' and
+        // use our own metadata entry to denote non-Component tag helpers.
+        public static readonly string SpecialKindKey = "Blazor.IsSpecialKind";
+
+        public static class Bind
+        {
+            public static readonly string RuntimeName = "Blazor.None";
+
+            public readonly static string TagHelperKind = "Blazor.Bind-0.1";
+
+            public readonly static string FallbackKey = "Blazor.Bind.Fallback";
+
+            public readonly static string TypeAttribute = "Blazor.Bind.TypeAttribute";
+
+            public readonly static string ValueAttribute = "Blazor.Bind.ValueAttribute";
+
+            public readonly static string ChangeAttribute = "Blazor.Bind.ChangeAttribute";
+        }
+
+        public static class Component
+        {
+            public static readonly string DelegateSignatureKey = "Blazor.DelegateSignature";
+
+            public static readonly string RuntimeName = "Blazor.IComponent";
+
+            public readonly static string TagHelperKind = "Blazor.Component-0.1";
+
+        }
+    }
+}

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/BlazorExtensionInitializer.cs

@@ -61,6 +61,31 @@ public ComponentAttributeExtensionNode(TagHelperPropertyIntermediateNode propert
             }
         }
 
+        public ComponentAttributeExtensionNode(ComponentAttributeExtensionNode attributeNode)
+        {
+            if (attributeNode == null)
+            {
+                throw new ArgumentNullException(nameof(attributeNode));
+            }
+
+            AttributeName = attributeNode.AttributeName;
+            AttributeStructure = attributeNode.AttributeStructure;
+            BoundAttribute = attributeNode.BoundAttribute;
+            PropertyName = attributeNode.BoundAttribute.GetPropertyName();
+            Source = attributeNode.Source;
+            TagHelper = attributeNode.TagHelper;
+
+            for (var i = 0; i < attributeNode.Children.Count; i++)
+            {
+                Children.Add(attributeNode.Children[i]);
+            }
+
+            for (var i = 0; i < attributeNode.Diagnostics.Count; i++)
+            {
+                Diagnostics.Add(attributeNode.Diagnostics[i]);
+            }
+        }
+
         public override IntermediateNodeCollection Children { get; } = new IntermediateNodeCollection();
 
         public string AttributeName { get; set; }

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/BlazorMetadata.cs

@@ -1,16 +1,17 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Linq;
 using Microsoft.AspNetCore.Razor.Language;
-using Microsoft.AspNetCore.Razor.Language.Extensions;
 using Microsoft.AspNetCore.Razor.Language.Intermediate;
 
 namespace Microsoft.AspNetCore.Blazor.Razor
 {
     internal class ComponentLoweringPass : IntermediateNodePassBase, IRazorOptimizationPass
     {
+        // Run after our *special* tag helpers get lowered.
+        public override int Order => 1000;
+
         protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentIntermediateNode documentNode)
         {
             var @namespace = documentNode.FindPrimaryNamespace();
@@ -26,20 +27,28 @@ protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentInte
             var nodes = documentNode.FindDescendantNodes<TagHelperIntermediateNode>();
             for (var i = 0; i < nodes.Count; i++)
             {
+                var count = 0;
                 var node = nodes[i];
-                if (node.TagHelpers.Count > 1)
+                for (var j = 0; j < node.TagHelpers.Count; j++)
                 {
-                    node.Diagnostics.Add(BlazorDiagnosticFactory.Create_MultipleComponents(node.Source, node.TagName, node.TagHelpers));
-                }
+                    if (node.TagHelpers[j].IsComponentTagHelper())
+                    {
+                        // Only allow a single component tag helper per element. We also have some *special* tag helpers
+                        // and they should have already been processed by now.
+                        if (count++ > 1)
+                        {
+                            node.Diagnostics.Add(BlazorDiagnosticFactory.Create_MultipleComponents(node.Source, node.TagName, node.TagHelpers));
+                            break;
+                        }
 
-                RewriteUsage(node, node.TagHelpers[0]);
+                        RewriteUsage(node, node.TagHelpers[j]);
+                    }
+                }
             }
         }
 
         private void RewriteUsage(TagHelperIntermediateNode node, TagHelperDescriptor tagHelper)
         {
-            // Ignore Kind here. Some versions of Razor have a bug in the serializer that ignores it.
-
             // We need to surround the contents of the node with open and close nodes to ensure the component
             // is scoped correctly.
             node.Children.Insert(0, new ComponentOpenExtensionNode()

src/Microsoft.AspNetCore.Blazor.Razor.Extensions/ComponentAttributeExtensionNode.cs

@@ -12,10 +12,6 @@ namespace Microsoft.AspNetCore.Blazor.Razor
 {
     internal class ComponentTagHelperDescriptorProvider : RazorEngineFeatureBase, ITagHelperDescriptorProvider
     {
-        public static readonly string DelegateSignatureMetadata = "Blazor.DelegateSignature";
-
-        public readonly static string ComponentTagHelperKind = ComponentDocumentClassifierPass.ComponentDocumentKind;
-        
         private static readonly SymbolDisplayFormat FullNameTypeDisplayFormat =
             SymbolDisplayFormat.FullyQualifiedFormat
                 .WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.Omitted)
@@ -78,12 +74,12 @@ private TagHelperDescriptor CreateDescriptor(INamedTypeSymbol type)
             var typeName = type.ToDisplayString(FullNameTypeDisplayFormat);
             var assemblyName = type.ContainingAssembly.Identity.Name;
 
-            var builder = TagHelperDescriptorBuilder.Create(ComponentTagHelperKind, typeName, assemblyName);
+            var builder = TagHelperDescriptorBuilder.Create(BlazorMetadata.Component.TagHelperKind, typeName, assemblyName);
             builder.SetTypeName(typeName);
 
             // This opts out this 'component' tag helper for any processing that's specific to the default
             // Razor ITagHelper runtime.
-            builder.Metadata[TagHelperMetadata.Runtime.Name] = "Blazor.IComponent";
+            builder.Metadata[TagHelperMetadata.Runtime.Name] = BlazorMetadata.Component.RuntimeName;
 
             var xml = type.GetDocumentationCommentXml();
             if (!string.IsNullOrEmpty(xml))
@@ -114,7 +110,7 @@ private TagHelperDescriptor CreateDescriptor(INamedTypeSymbol type)
 
                     if (property.kind == PropertyKind.Delegate)
                     {
-                        pb.Metadata.Add(DelegateSignatureMetadata, bool.TrueString);
+                        pb.Metadata.Add(BlazorMetadata.Component.DelegateSignatureKey, bool.TrueString);
                     }
 
                     xml = property.property.GetDocumentationCommentXml();