Addressed code review comments.

Author: N. Taylor Mullen

src/Microsoft.AspNet.Razor/Generator/Compiler/CodeBuilder/CSharp/CSharpTagHelperCodeRenderer.cs

@@ -16,10 +16,10 @@ namespace Microsoft.AspNet.Razor.Generator.Compiler.CSharp
     /// </summary>
     public class CSharpTagHelperCodeRenderer
     {
-        internal static readonly string TagHelperExecutionContextVariableName = "__executionContext";
-        internal static readonly string BufferedStringValueVariableName = "__tagHelperBufferedStringValue";
-        internal static readonly string TagHelperScopeManagerVariableName = "__tagHelperScopeManager";
-        internal static readonly string TagHelperRunnerVariableName = "__tagHelperRunner";
+        internal static readonly string ExecutionContextVariableName = "__tagHelperExecutionContext";
+        internal static readonly string StringValueBufferVariableName = "__tagHelperStringValueBuffer";
+        internal static readonly string ScopeManagerVariableName = "__tagHelperScopeManager";
+        internal static readonly string RunnerVariableName = "__tagHelperRunner";
 
         private static readonly TagHelperAttributeDescriptorComparer AttributeDescriptorComparer =
             new TagHelperAttributeDescriptorComparer();
@@ -130,9 +130,9 @@ private void RenderBeginTagHelperScope(string tagName, ContentBehavior contentBe
         {
             // Call into the tag helper scope manager to start a new tag helper scope.
             // Also capture the value as the current execution context.
-            _writer.WriteStartAssignment(TagHelperExecutionContextVariableName)
-                   .WriteStartInstanceMethodInvocation(TagHelperScopeManagerVariableName,
-                                                       _tagHelperContext.TagHelperScopeManagerBeginMethodName);
+            _writer.WriteStartAssignment(ExecutionContextVariableName)
+                   .WriteStartInstanceMethodInvocation(ScopeManagerVariableName,
+                                                       _tagHelperContext.ScopeManagerBeginMethodName);
             _writer.WriteStringLiteral(tagName)
                    .WriteEndMethodInvocation();
         }
@@ -157,7 +157,7 @@ private void RenderTagHelpersCreation(TagHelperChunk chunk)
                                                    tagHelperDescriptor.TagHelperName)
                        .WriteEndMethodInvocation();
 
-                _writer.WriteInstanceMethodInvocation(TagHelperExecutionContextVariableName,
+                _writer.WriteInstanceMethodInvocation(ExecutionContextVariableName,
                                                       _tagHelperContext.ExecutionContextAddMethodName,
                                                       tagHelperVariableName);
 
@@ -243,7 +243,7 @@ private void RenderBoundHTMLAttributes(IDictionary<string, Chunk> chunkAttribute
 
                         // We need to inform the context of the attribute value.
                         _writer.WriteStartInstanceMethodInvocation(
-                            TagHelperExecutionContextVariableName,
+                            ExecutionContextVariableName,
                             _tagHelperContext.ExecutionContextAddTagHelperAttributeMethodName);
 
                         _writer.WriteStringLiteral(attributeDescriptor.AttributeName)
@@ -277,7 +277,7 @@ private void RenderUnboundHTMLAttributes(IEnumerable<KeyValuePair<string, Chunk>
                     BuildBufferedAttributeValue(attributeValue);
                 }
 
-                _writer.WriteStartInstanceMethodInvocation(TagHelperExecutionContextVariableName,
+                _writer.WriteStartInstanceMethodInvocation(ExecutionContextVariableName,
                                                            _tagHelperContext.ExecutionContextAddHtmlAttributeMethodName);
                 _writer.WriteStringLiteral(htmlAttribute.Key)
                        .WriteParameterSeparator();
@@ -316,45 +316,45 @@ private void RenderTagHelperBody(IList<Chunk> children, ContentBehavior contentB
 
         private void RenderEndTagHelpersScope()
         {
-            _writer.WriteStartAssignment(TagHelperExecutionContextVariableName)
-                   .WriteInstanceMethodInvocation(TagHelperScopeManagerVariableName,
-                                                  _tagHelperContext.TagHelperScopeManagerEndMethodName);
+            _writer.WriteStartAssignment(ExecutionContextVariableName)
+                   .WriteInstanceMethodInvocation(ScopeManagerVariableName,
+                                                  _tagHelperContext.ScopeManagerEndMethodName);
         }
 
         private void RenderTagOutput(string tagOutputMethodName)
         {
             CSharpCodeVisitor.RenderPreWriteStart(_writer, _context);
 
-            _writer.Write(TagHelperExecutionContextVariableName)
+            _writer.Write(ExecutionContextVariableName)
                    .Write(".")
                    .Write(_tagHelperContext.ExecutionContextOutputPropertyName)
                    .Write(".")
                    .WriteMethodInvocation(tagOutputMethodName, endLine: false)
-                   .WriteEndMethodInvocation(); ;
+                   .WriteEndMethodInvocation();
         }
 
         private void RenderRunTagHelpers(bool bufferedBody)
         {
-            _writer.Write(TagHelperExecutionContextVariableName)
+            _writer.Write(ExecutionContextVariableName)
                    .Write(".")
                    .Write(_tagHelperContext.ExecutionContextOutputPropertyName)
                    .Write(" = await ")
-                   .WriteStartInstanceMethodInvocation(TagHelperRunnerVariableName,
-                                                       _tagHelperContext.TagHelperRunnerRunAsyncMethodName);
-            _writer.Write(TagHelperExecutionContextVariableName);
+                   .WriteStartInstanceMethodInvocation(RunnerVariableName,
+                                                       _tagHelperContext.RunnerRunAsyncMethodName);
+            _writer.Write(ExecutionContextVariableName);
 
             if (bufferedBody)
             {
                 _writer.WriteParameterSeparator()
-                       .Write(BufferedStringValueVariableName);
+                       .Write(StringValueBufferVariableName);
             }
 
             _writer.WriteEndMethodInvocation();
         }
 
         private void RenderBufferedAttributeValueAccessor()
         {
-            _writer.WriteInstanceMethodInvocation(BufferedStringValueVariableName,
+            _writer.WriteInstanceMethodInvocation(StringValueBufferVariableName,
                                                   "ToString",
                                                   endLine: false);
         }
@@ -404,7 +404,7 @@ private void BuildBufferedWritingScope(Action renderCode)
 
             renderCode();
 
-            _writer.WriteStartAssignment(BufferedStringValueVariableName)
+            _writer.WriteStartAssignment(StringValueBufferVariableName)
                    .WriteMethodInvocation(_tagHelperContext.EndWritingScopeMethodName);
         }
 
@@ -416,7 +416,7 @@ private void RenderAttributeValue(TagHelperAttributeDescriptor attributeDescript
 
         private static bool IsStringAttribute(TagHelperAttributeDescriptor attributeDescriptor)
         {
-            return typeof(string) == attributeDescriptor.PropertyInfo.PropertyType;
+            return attributeDescriptor.PropertyInfo.PropertyType == typeof(string);
         }
 
         private static bool TryGetPlainTextValue(Chunk chunk, out string plainText)

src/Microsoft.AspNet.Razor/Generator/Compiler/CodeBuilder/CSharp/Visitors/CSharpTagHelperDeclarationVisitor.cs

@@ -9,9 +9,9 @@ namespace Microsoft.AspNet.Razor.Generator.Compiler.CSharp
 {
     public class CSharpTagHelperDeclarationVisitor : CodeVisitor<CSharpCodeWriter>
     {
+        private readonly HashSet<TagHelperDescriptor> _declaredDescriptors;
+        private readonly GeneratedTagHelperContext _tagHelperContext;
         private bool _foundTagHelpers;
-        private HashSet<TagHelperDescriptor> _declaredDescriptors;
-        private GeneratedTagHelperContext _tagHelperContext;
 
         public CSharpTagHelperDeclarationVisitor([NotNull] CSharpCodeWriter writer,
                                                  [NotNull] CodeBuilderContext context)
@@ -29,20 +29,20 @@ protected override void Visit(TagHelperChunk chunk)
                 _foundTagHelpers = true;
 
                 Writer.WriteVariableDeclaration(typeof(TextWriter).FullName,
-                                                CSharpTagHelperCodeRenderer.BufferedStringValueVariableName,
+                                                CSharpTagHelperCodeRenderer.StringValueBufferVariableName,
                                                 null);
 
-                Writer.WriteVariableDeclaration(_tagHelperContext.TagHelpersExecutionContextTypeName,
-                                                CSharpTagHelperCodeRenderer.TagHelperExecutionContextVariableName,
+                Writer.WriteVariableDeclaration(_tagHelperContext.ExecutionContextTypeName,
+                                                CSharpTagHelperCodeRenderer.ExecutionContextVariableName,
                                                 null);
 
                 Writer.WriteVariableDeclaration("var",
-                                                CSharpTagHelperCodeRenderer.TagHelperRunnerVariableName,
-                                                "new " + _tagHelperContext.TagHelperRunnerTypeName + "()");
+                                                CSharpTagHelperCodeRenderer.RunnerVariableName,
+                                                "new " + _tagHelperContext.RunnerTypeName + "()");
 
                 Writer.WriteVariableDeclaration("var",
-                                                CSharpTagHelperCodeRenderer.TagHelperScopeManagerVariableName,
-                                                "new " + _tagHelperContext.TagHelperScopeManagerTypeName + "()");
+                                                CSharpTagHelperCodeRenderer.ScopeManagerVariableName,
+                                                "new " + _tagHelperContext.ScopeManagerTypeName + "()");
             }
 
             foreach (var descriptor in chunk.Descriptors)

src/Microsoft.AspNet.Razor/Generator/Compiler/CodeBuilder/CSharp/Visitors/CSharpUsingVisitor.cs

@@ -53,7 +53,7 @@ protected override void Visit(UsingChunk chunk)
 
         protected override void Visit(TagHelperChunk chunk)
         {
-            if(!_foundTagHelpers)
+            if (!_foundTagHelpers)
             {
                 _foundTagHelpers = true;
 

src/Microsoft.AspNet.Razor/Generator/GeneratedClassContext.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.AspNet.Razor.Generator
 {
-    public class GeneratedClassContext
+    public struct GeneratedClassContext
     {
         public static readonly string DefaultWriteMethodName = "Write";
         public static readonly string DefaultWriteLiteralMethodName = "WriteLiteral";
@@ -25,6 +25,7 @@ public GeneratedClassContext(GeneratedTagHelperContext generatedTagHelperContext
                                      string executeMethodName,
                                      string writeMethodName,
                                      string writeLiteralMethodName)
+            : this()
         {
             if (generatedTagHelperContext == null)
             {

src/Microsoft.AspNet.Razor/Generator/GeneratedTagHelperContext.cs

@@ -17,12 +17,12 @@ public class GeneratedTagHelperContext
         /// <summary>
         /// Instantiates a new instance of the <see cref="GeneratedTagHelperContext"/> with default values.
         /// </summary>
-        public GeneratedTagHelperContext()
+        private GeneratedTagHelperContext()
         {
             CreateTagHelperMethodName = "CreateTagHelper";
-            TagHelperRunnerRunAsyncMethodName = "RunAsync";
-            TagHelperScopeManagerBeginMethodName = "Begin";
-            TagHelperScopeManagerEndMethodName = "End";
+            RunnerRunAsyncMethodName = "RunAsync";
+            ScopeManagerBeginMethodName = "Begin";
+            ScopeManagerEndMethodName = "End";
             TagHelperOutputGenerateStartTagMethodName = "GenerateStartTag";
             TagHelperOutputGenerateContentMethodName = "GenerateContent";
             TagHelperOutputGenerateEndTagMethodName = "GenerateEndTag";
@@ -32,98 +32,97 @@ public GeneratedTagHelperContext()
             ExecutionContextOutputPropertyName = "Output";
             StartWritingScopeMethodName = "StartWritingScope";
             EndWritingScopeMethodName = "EndWritingScope";
-            TagHelperRunnerTypeName = "TagHelperRunner";
-            TagHelperScopeManagerTypeName = "TagHelperScopeManager";
-            TagHelpersExecutionContextTypeName = "TagHelperExecutionContext";
+            RunnerTypeName = "TagHelperRunner";
+            ScopeManagerTypeName = "TagHelperScopeManager";
+            ExecutionContextTypeName = "TagHelperExecutionContext";
         }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to create a tag helper.
+        /// The name of the method used to create a tag helper.
         /// </summary>
         public string CreateTagHelperMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to run a tag helpers defined by the type
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The name of the method used to run tag helpers.
         /// </summary>
-        public string TagHelperRunnerRunAsyncMethodName { get; set; }
+        public string RunnerRunAsyncMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to start a scope for the type defined by
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The name of the method used to start a scope for the type defined by
+        /// <see cref="ExecutionContextTypeName"/>.
         /// </summary>
-        public string TagHelperScopeManagerBeginMethodName { get; set; }
+        public string ScopeManagerBeginMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to end a scope for the type defined by
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The name of the method used to end a scope for the type defined by
+        /// <see cref="ExecutionContextTypeName"/>.
         /// </summary>
-        public string TagHelperScopeManagerEndMethodName { get; set; }
+        public string ScopeManagerEndMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to generate a tag helper outputs start tag.
+        /// The name of the method used to generate a tag helper output's start tag.
         /// </summary>
         public string TagHelperOutputGenerateStartTagMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to generate a tag helper outputs content.
+        /// The name of the method used to generate a tag helper outputs content.
         /// </summary>
         public string TagHelperOutputGenerateContentMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to generate a tag helper outputs end tag.
+        /// The name of the method used to generate a tag helper outputs end tag.
         /// </summary>
         public string TagHelperOutputGenerateEndTagMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to add tag helper attributes to the type defined by
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The method in <see cref="ExecutionContextTypeName"/> used to add tag helper attributes.
         /// </summary>
         public string ExecutionContextAddTagHelperAttributeMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to add HTML attributes to the type defined by
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The name of the method used to add HTML attributes to the type defined by
+        /// <see cref="ExecutionContextTypeName"/>.
         /// </summary>
         public string ExecutionContextAddHtmlAttributeMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to add tag helpers to the type defined by
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The name of the method used to add tag helpers to the type defined by
+        /// <see cref="ExecutionContextTypeName"/>.
         /// </summary>
         public string ExecutionContextAddMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> property accessor for the tag helpers output.
+        /// The property accessor for the tag helper's output.
         /// </summary>
         public string ExecutionContextOutputPropertyName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name to start a new writing scope on the generated Razor page.
+        /// The name of the method to start a new writing scope.
         /// </summary>
         public string StartWritingScopeMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> method name used to end a writing scope that was started from a call to the method
+        /// The name of the method used to end a writing scope that was started from a call to the method
         /// defined by <see cref="StartWritingScopeMethodName"/> on the generated Razor page.
         /// </summary>
         public string EndWritingScopeMethodName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> type name of the object used to run tag helpers.
+        /// The name of the type used to run tag helpers.
         /// </summary>
-        public string TagHelperRunnerTypeName { get; set; }
+        public string RunnerTypeName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> type name of the object used to create scoped objects of the type defined by
-        /// <see cref="TagHelpersExecutionContextTypeName"/>.
+        /// The name of the type used to create scoped <see cref="ExecutionContextTypeName"/> instances.
         /// </summary>
-        public string TagHelperScopeManagerTypeName { get; set; }
+        public string ScopeManagerTypeName { get; set; }
 
         /// <summary>
-        /// The <see cref="string"/> type name of the object used manage tag helpers, tag helper attributes, 
-        /// html attributes, the HTML tag name and the tag helpers output.
+        /// The name of the type [describing|containing information about] a specific tag helper scope.
         /// </summary>
-        public string TagHelpersExecutionContextTypeName { get; set; }
+        /// <remarks>
+        /// Contains information about in-scope tag helpers, HTML attributes, and the tag helpers' output.
+        /// </remarks>
+        public string ExecutionContextTypeName { get; set; }
     }
 }