Addressed code review comments.

Author: N. Taylor Mullen

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

@@ -430,7 +430,6 @@ private void RenderRawAttributeValue(string value,
                 attributeDescriptor,
                 valueRenderer: (writer) =>
                 {
-                    // We only want to do the work of generating a line mapping if we're in design time mode.
                     if (_context.Host.DesignTimeMode)
                     {
                         using (new CSharpLineMappingWriter(_writer, documentLocation, value.Length))

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

@@ -62,11 +62,12 @@ public override void GenerateStartBlockCode(Block target, CodeGeneratorContext c
                 attribute.Value.Accept(codeGenerator);
 
                 var chunks = codeGenerator.Context.CodeTreeBuilder.CodeTree.Chunks;
+                var first = chunks.FirstOrDefault();
 
                 attributes[attribute.Key] = new ChunkBlock
                 {
                     Children = chunks,
-                    Start = chunks.FirstOrDefault()?.Start ?? SourceLocation.Zero
+                    Start = first == null ? SourceLocation.Zero : first.Start
                 };
 
                 // Reset the code tree builder so we can build a new one for the next attribute

src/Microsoft.AspNet.Razor/Parser/TagHelpers/TagHelperBlockBuilder.cs

@@ -177,24 +177,25 @@ private static KeyValuePair<string, SyntaxTreeNode> ParseSpan(
             {
                 var symbol = htmlSymbols[i];
 
-                if (name == null && symbol.Type == HtmlSymbolType.Text)
+                if (afterEquals)
                 {
-                    name = symbol.Content;
-                }
-                else if (afterEquals)
-                {
-                    // When symbols are accepted into SpanBuilders their locations get altered to abide by the 
+                    // When symbols are accepted into SpanBuilders their locations get altered to be offset by the 
                     // parent which is why we need to mark our start location prior to adding the symbol so we know
                     // the location of the attribute value start within the document.
                     if (!capturedAttributeValueStart)
                     {
                         capturedAttributeValueStart = true;
 
-                        attributeValueStartLocation += symbol.Start;
+                        attributeValueStartLocation = span.Start + symbol.Start;
                     }
 
                     builder.Accept(symbol);
                 }
+                else if (name == null && symbol.Type == HtmlSymbolType.Text)
+                {
+                    name = symbol.Content;
+                    attributeValueStartLocation = SourceLocation.Advance(span.Start, name);
+                }
                 else if (symbol.Type == HtmlSymbolType.Equals)
                 {
                     // We've found an '=' symbol, this means that the coming symbols will either be a quote
@@ -205,24 +206,30 @@ private static KeyValuePair<string, SyntaxTreeNode> ParseSpan(
                     // TODO: Handle malformed tags, if there's an '=' then there MUST be a value.
                     // https://github.com/aspnet/Razor/issues/104
 
+                    SourceLocation symbolStartLocation;
+
                     // Check for attribute start values, aka single or double quote
                     if (IsQuote(htmlSymbols[i + 1]))
                     {
                         // Move past the attribute start so we can accept the true value.
                         i++;
+                        symbolStartLocation = htmlSymbols[i + 1].Start;
                     }
                     else
                     {
+                        symbolStartLocation = symbol.Start;
+
                         // Set the symbol offset to 0 so we don't attempt to skip an end quote that doesn't exist.
                         symbolOffset = 0;
                     }
 
+                    attributeValueStartLocation = symbolStartLocation + span.Start + SourceLocation.One;
                     afterEquals = true;
                 }
             }
 
-            // After all symbols have been added we need to offset the builders start position. Adding symbols to a
-            // SpanBuilder alters its position prior to it being occupied.
+            // After all symbols have been added we need to set the builders start position so we do not indirectly
+            // modify each symbols Start location.
             builder.Start = attributeValueStartLocation;
 
             return CreateMarkupAttribute(name, builder, attributeValueTypes);

src/Microsoft.AspNet.Razor/Text/SourceLocation.cs

@@ -14,6 +14,7 @@ public struct SourceLocation : IEquatable<SourceLocation>, IComparable<SourceLoc
     {
         public static readonly SourceLocation Undefined = CreateUndefined();
         public static readonly SourceLocation Zero = new SourceLocation(0, 0, 0);
+        public static readonly SourceLocation One = new SourceLocation(1, 0, 1);
 
         private int _absoluteIndex;
         private int _lineIndex;