From 40633dde21a1ce42bb56f762ca8f74ca0c1cd512 Mon Sep 17 00:00:00 2001
From: Ryan Nowak <nowakra@gmail.com>
Date: Mon, 14 Jan 2019 08:24:20 -0800
Subject: [PATCH] Add attribute only bindings and fix
 dotnet/aspnetcore-tooling#6373

Adds a new API for WTE to call given a TagHelperBinding to determine if
the binding should colorize/classify only the attributes of the HTML
element in source code. This is driven by a new metadata item that the
Components 'directive attributes' all set. There's no way for a user to
access this feature via tag helpers currently, but it could be added
easily in the future.

Also fixing dotnet/aspnetcore-tooling#6376 while I'm in there. :+1:
\n\nCommit migrated from https://github.com/dotnet/aspnetcore-tooling/commit/df449beea9085221a1ba75ee61dcfbd2beb3aa34
---
 .../src/Legacy/TagHelperBlockRewriter.cs      |  2 +-
 .../src/Legacy/TagHelperParseTreeRewriter.cs  |  4 +-
 .../src/TagHelperBinding.cs                   | 46 +++++++++++++++++--
 .../src/TagHelperMetadata.cs                  |  2 +
 .../src/BindTagHelperDescriptorProvider.cs    |  2 +
 ...EventHandlerTagHelperDescriptorProvider.cs |  2 +-
 .../src/RefTagHelperDescriptorProvider.cs     | 15 ++++++
 .../BindTagHelperDescriptorProviderTest.cs    |  2 +
 ...tHandlerTagHelperDescriptorProviderTest.cs |  5 +-
 .../RefTagHelperDescriptorProviderTest.cs     |  3 ++
 10 files changed, 72 insertions(+), 11 deletions(-)

diff --git a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperBlockRewriter.cs b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperBlockRewriter.cs
index fefcf4aeee..23a0a488a1 100644
--- a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperBlockRewriter.cs
+++ b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperBlockRewriter.cs
@@ -40,7 +40,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy
 
             foreach (var descriptor in bindingResult.Descriptors)
             {
-                var boundRules = bindingResult.GetBoundRules(descriptor);
+                var boundRules = bindingResult.Mappings[descriptor];
                 var nonDefaultRule = boundRules.FirstOrDefault(rule => rule.TagStructure != TagStructure.Unspecified);
 
                 if (nonDefaultRule?.TagStructure == TagStructure.WithoutEndTag)
diff --git a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperParseTreeRewriter.cs b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperParseTreeRewriter.cs
index 47f96d7d3b..1619f42240 100644
--- a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperParseTreeRewriter.cs
+++ b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/TagHelperParseTreeRewriter.cs
@@ -336,7 +336,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy
 
                     foreach (var descriptor in tagHelperBinding.Descriptors)
                     {
-                        var boundRules = tagHelperBinding.GetBoundRules(descriptor);
+                        var boundRules = tagHelperBinding.Mappings[descriptor];
                         var invalidRule = boundRules.FirstOrDefault(rule => rule.TagStructure == TagStructure.WithoutEndTag);
 
                         if (invalidRule != null)
@@ -456,7 +456,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy
                 TagStructure? baseStructure = null;
                 foreach (var descriptor in bindingResult.Descriptors)
                 {
-                    var boundRules = bindingResult.GetBoundRules(descriptor);
+                    var boundRules = bindingResult.Mappings[descriptor];
                     foreach (var rule in boundRules)
                     {
                         if (rule.TagStructure != TagStructure.Unspecified)
diff --git a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperBinding.cs b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperBinding.cs
index a5590c536e..4b88cf5b12 100644
--- a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperBinding.cs
+++ b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperBinding.cs
@@ -1,14 +1,13 @@
 // 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;
 
 namespace Microsoft.AspNetCore.Razor.Language
 {
     public sealed class TagHelperBinding
     {
-        private IReadOnlyDictionary<TagHelperDescriptor, IReadOnlyList<TagMatchingRuleDescriptor>> _mappings;
-
         internal TagHelperBinding(
             string tagName,
             IReadOnlyList<KeyValuePair<string, string>> attributes,
@@ -19,12 +18,42 @@ namespace Microsoft.AspNetCore.Razor.Language
             TagName = tagName;
             Attributes = attributes;
             ParentTagName = parentTagName;
+            Mappings = mappings;
             TagHelperPrefix = tagHelperPrefix;
 
-            _mappings = mappings;
         }
 
-        public IEnumerable<TagHelperDescriptor> Descriptors => _mappings.Keys;
+        public IEnumerable<TagHelperDescriptor> Descriptors => Mappings.Keys;
+
+        /// <summary>
+        /// Gets a value that indicates whether the the binding matched on attributes only.
+        /// </summary>
+        /// <returns><c>false</c> if the entire element should be classified as a tag helper.</returns>
+        /// <remarks>
+        /// If this returns <c>true</c>, use <c>TagHelperFactsService.GetBoundTagHelperAttributes</c> to find the 
+        /// set of attributes that should be considered part of the match.
+        /// </remarks>
+        public bool IsAttributeMatch
+        {
+            get
+            {
+                foreach (var descriptor in Mappings.Keys)
+                {
+                    if (!descriptor.Metadata.TryGetValue(TagHelperMetadata.Common.ClassifyAttributesOnly, out var value) ||
+                        !string.Equals(value, bool.TrueString, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return false;
+                    }
+                }
+
+                // All the matching tag helpers want to be classified with **attributes only**.
+                //
+                // Ex: (components)
+                //
+                //      <button onclick="..." />
+                return true;
+            }
+        }
 
         public string TagName { get; }
 
@@ -32,11 +61,18 @@ namespace Microsoft.AspNetCore.Razor.Language
 
         public IReadOnlyList<KeyValuePair<string, string>> Attributes { get; }
 
+        public IReadOnlyDictionary<TagHelperDescriptor, IReadOnlyList<TagMatchingRuleDescriptor>> Mappings { get; }
+
         public string TagHelperPrefix { get; }
 
         public IReadOnlyList<TagMatchingRuleDescriptor> GetBoundRules(TagHelperDescriptor descriptor)
         {
-            return _mappings[descriptor];
+            if (descriptor == null)
+            {
+                throw new ArgumentNullException(nameof(descriptor));
+            }
+
+            return Mappings[descriptor];
         }
     }
 }
\ No newline at end of file
diff --git a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperMetadata.cs b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperMetadata.cs
index e53f471a57..f1cf98ebd9 100644
--- a/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperMetadata.cs
+++ b/src/Razor/Microsoft.AspNetCore.Razor.Language/src/TagHelperMetadata.cs
@@ -10,6 +10,8 @@ namespace Microsoft.AspNetCore.Razor.Language
             public static readonly string PropertyName = "Common.PropertyName";
 
             public static readonly string TypeName = "Common.TypeName";
+
+            public static readonly string ClassifyAttributesOnly = "Common.ClassifyAttributesOnly";
         }
 
         public static class Runtime
diff --git a/src/Razor/Microsoft.CodeAnalysis.Razor/src/BindTagHelperDescriptorProvider.cs b/src/Razor/Microsoft.CodeAnalysis.Razor/src/BindTagHelperDescriptorProvider.cs
index 02bf8e3fcf..4310a9f24e 100644
--- a/src/Razor/Microsoft.CodeAnalysis.Razor/src/BindTagHelperDescriptorProvider.cs
+++ b/src/Razor/Microsoft.CodeAnalysis.Razor/src/BindTagHelperDescriptorProvider.cs
@@ -121,6 +121,7 @@ namespace Microsoft.CodeAnalysis.Razor
             builder.Documentation = ComponentResources.BindTagHelper_Fallback_Documentation;
 
             builder.Metadata.Add(BlazorMetadata.SpecialKindKey, BlazorMetadata.Bind.TagHelperKind);
+            builder.Metadata.Add(TagHelperMetadata.Common.ClassifyAttributesOnly, bool.TrueString);
             builder.Metadata[TagHelperMetadata.Runtime.Name] = BlazorMetadata.Bind.RuntimeName;
             builder.Metadata[BlazorMetadata.Bind.FallbackKey] = bool.TrueString;
 
@@ -257,6 +258,7 @@ namespace Microsoft.CodeAnalysis.Razor
                     entry.ChangeAttribute);
 
                 builder.Metadata.Add(BlazorMetadata.SpecialKindKey, BlazorMetadata.Bind.TagHelperKind);
+                builder.Metadata.Add(TagHelperMetadata.Common.ClassifyAttributesOnly, bool.TrueString);
                 builder.Metadata[TagHelperMetadata.Runtime.Name] = BlazorMetadata.Bind.RuntimeName;
                 builder.Metadata[BlazorMetadata.Bind.ValueAttribute] = entry.ValueAttribute;
                 builder.Metadata[BlazorMetadata.Bind.ChangeAttribute] = entry.ChangeAttribute;
diff --git a/src/Razor/Microsoft.CodeAnalysis.Razor/src/EventHandlerTagHelperDescriptorProvider.cs b/src/Razor/Microsoft.CodeAnalysis.Razor/src/EventHandlerTagHelperDescriptorProvider.cs
index 17ed23ae1b..370702706f 100644
--- a/src/Razor/Microsoft.CodeAnalysis.Razor/src/EventHandlerTagHelperDescriptorProvider.cs
+++ b/src/Razor/Microsoft.CodeAnalysis.Razor/src/EventHandlerTagHelperDescriptorProvider.cs
@@ -35,7 +35,6 @@ namespace Microsoft.CodeAnalysis.Razor
                 return;
             }
 
-
             var eventHandlerData = GetEventHandlerData(compilation);
 
             foreach (var tagHelper in CreateEventHandlerTagHelpers(eventHandlerData))
@@ -112,6 +111,7 @@ namespace Microsoft.CodeAnalysis.Razor
 
                 builder.Metadata.Add(BlazorMetadata.SpecialKindKey, BlazorMetadata.EventHandler.TagHelperKind);
                 builder.Metadata.Add(BlazorMetadata.EventHandler.EventArgsType, entry.EventArgsType.ToDisplayString());
+                builder.Metadata.Add(TagHelperMetadata.Common.ClassifyAttributesOnly, bool.TrueString);
                 builder.Metadata[TagHelperMetadata.Runtime.Name] = BlazorMetadata.EventHandler.RuntimeName;
 
                 // WTE has a bug in 15.7p1 where a Tag Helper without a display-name that looks like
diff --git a/src/Razor/Microsoft.CodeAnalysis.Razor/src/RefTagHelperDescriptorProvider.cs b/src/Razor/Microsoft.CodeAnalysis.Razor/src/RefTagHelperDescriptorProvider.cs
index 858f9428d7..735269334f 100644
--- a/src/Razor/Microsoft.CodeAnalysis.Razor/src/RefTagHelperDescriptorProvider.cs
+++ b/src/Razor/Microsoft.CodeAnalysis.Razor/src/RefTagHelperDescriptorProvider.cs
@@ -21,6 +21,20 @@ namespace Microsoft.CodeAnalysis.Razor
                 throw new ArgumentNullException(nameof(context));
             }
 
+            var compilation = context.GetCompilation();
+            if (compilation == null)
+            {
+                return;
+            }
+
+            var elementRef = compilation.GetTypeByMetadataName(ComponentsApi.ElementRef.FullTypeName);
+            if (elementRef == null)
+            {
+                // If we can't find ElementRef, then just bail. We won't be able to compile the
+                // generated code anyway.
+                return;
+            }
+
             context.Results.Add(CreateRefTagHelper());
         }
 
@@ -30,6 +44,7 @@ namespace Microsoft.CodeAnalysis.Razor
             builder.Documentation = ComponentResources.RefTagHelper_Documentation;
 
             builder.Metadata.Add(BlazorMetadata.SpecialKindKey, BlazorMetadata.Ref.TagHelperKind);
+            builder.Metadata.Add(TagHelperMetadata.Common.ClassifyAttributesOnly, bool.TrueString);
             builder.Metadata[TagHelperMetadata.Runtime.Name] = BlazorMetadata.Ref.RuntimeName;
 
             // WTE has a bug in 15.7p1 where a Tag Helper without a display-name that looks like
diff --git a/src/Razor/Microsoft.CodeAnalysis.Razor/test/BindTagHelperDescriptorProviderTest.cs b/src/Razor/Microsoft.CodeAnalysis.Razor/test/BindTagHelperDescriptorProviderTest.cs
index 5551fcdf53..9c28a2be24 100644
--- a/src/Razor/Microsoft.CodeAnalysis.Razor/test/BindTagHelperDescriptorProviderTest.cs
+++ b/src/Razor/Microsoft.CodeAnalysis.Razor/test/BindTagHelperDescriptorProviderTest.cs
@@ -207,6 +207,7 @@ namespace Test
             Assert.Empty(bind.Diagnostics);
             Assert.False(bind.HasErrors);
             Assert.Equal(BlazorMetadata.Bind.TagHelperKind, bind.Kind);
+            Assert.Equal(bool.TrueString, bind.Metadata[TagHelperMetadata.Common.ClassifyAttributesOnly]);
             Assert.Equal(BlazorMetadata.Bind.RuntimeName, bind.Metadata[TagHelperMetadata.Runtime.Name]);
             Assert.False(bind.IsDefaultKind());
             Assert.False(bind.KindUsesDefaultTagHelperRuntime());
@@ -571,6 +572,7 @@ namespace Test
             Assert.Empty(bind.Diagnostics);
             Assert.False(bind.HasErrors);
             Assert.Equal(BlazorMetadata.Bind.TagHelperKind, bind.Kind);
+            Assert.Equal(bool.TrueString, bind.Metadata[TagHelperMetadata.Common.ClassifyAttributesOnly]);
             Assert.Equal(BlazorMetadata.Bind.RuntimeName, bind.Metadata[TagHelperMetadata.Runtime.Name]);
             Assert.False(bind.IsDefaultKind());
             Assert.False(bind.KindUsesDefaultTagHelperRuntime());
diff --git a/src/Razor/Microsoft.CodeAnalysis.Razor/test/EventHandlerTagHelperDescriptorProviderTest.cs b/src/Razor/Microsoft.CodeAnalysis.Razor/test/EventHandlerTagHelperDescriptorProviderTest.cs
index f2f18c1997..c0140ebbcd 100644
--- a/src/Razor/Microsoft.CodeAnalysis.Razor/test/EventHandlerTagHelperDescriptorProviderTest.cs
+++ b/src/Razor/Microsoft.CodeAnalysis.Razor/test/EventHandlerTagHelperDescriptorProviderTest.cs
@@ -4,10 +4,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.AspNetCore.Razor.Language;
-using Microsoft.CodeAnalysis.Razor;
+using Microsoft.AspNetCore.Razor.Language.Components;
 using Xunit;
 
-namespace Microsoft.AspNetCore.Razor.Language.Components
+namespace Microsoft.CodeAnalysis.Razor
 {
     public class EventHandlerTagHelperDescriptorProviderTest : BaseTagHelperDescriptorProviderTest
     {
@@ -52,6 +52,7 @@ namespace Test
             Assert.Empty(item.Diagnostics);
             Assert.False(item.HasErrors);
             Assert.Equal(BlazorMetadata.EventHandler.TagHelperKind, item.Kind);
+            Assert.Equal(bool.TrueString, item.Metadata[TagHelperMetadata.Common.ClassifyAttributesOnly]);
             Assert.Equal(BlazorMetadata.EventHandler.RuntimeName, item.Metadata[TagHelperMetadata.Runtime.Name]);
             Assert.False(item.IsDefaultKind());
             Assert.False(item.KindUsesDefaultTagHelperRuntime());
diff --git a/src/Razor/Microsoft.CodeAnalysis.Razor/test/RefTagHelperDescriptorProviderTest.cs b/src/Razor/Microsoft.CodeAnalysis.Razor/test/RefTagHelperDescriptorProviderTest.cs
index 0c6939336a..fa47fce6b7 100644
--- a/src/Razor/Microsoft.CodeAnalysis.Razor/test/RefTagHelperDescriptorProviderTest.cs
+++ b/src/Razor/Microsoft.CodeAnalysis.Razor/test/RefTagHelperDescriptorProviderTest.cs
@@ -15,6 +15,8 @@ namespace Microsoft.CodeAnalysis.Razor
         {
             // Arrange
             var context = TagHelperDescriptorProviderContext.Create();
+            context.SetCompilation(BaseCompilation);
+
             var provider = new RefTagHelperDescriptorProvider();
 
             // Act
@@ -29,6 +31,7 @@ namespace Microsoft.CodeAnalysis.Razor
             Assert.Empty(item.Diagnostics);
             Assert.False(item.HasErrors);
             Assert.Equal(BlazorMetadata.Ref.TagHelperKind, item.Kind);
+            Assert.Equal(bool.TrueString, item.Metadata[TagHelperMetadata.Common.ClassifyAttributesOnly]);
             Assert.Equal(BlazorMetadata.Ref.RuntimeName, item.Metadata[TagHelperMetadata.Runtime.Name]);
             Assert.False(item.IsDefaultKind());
             Assert.False(item.KindUsesDefaultTagHelperRuntime());