Rewrite WhitespaceRewriter (#2604)

* Rewrite WhitespaceRewriter

* Rename CSharpExpression to CSharpExplicitExpression

Author: ajaybhargavb

src/Microsoft.AspNetCore.Razor.Language/ClassifiedSpanVisitor.cs

@@ -33,7 +33,7 @@ public override SyntaxNode VisitRazorCommentBlock(RazorCommentBlockSyntax node)
         public override SyntaxNode VisitCSharpCodeBlock(CSharpCodeBlockSyntax node)
         {
             if (node.Parent is CSharpStatementBodySyntax ||
-                node.Parent is CSharpExpressionBodySyntax ||
+                node.Parent is CSharpExplicitExpressionBodySyntax ||
                 node.Parent is CSharpImplicitExpressionBodySyntax ||
                 node.Parent is RazorDirectiveBodySyntax)
             {
@@ -43,17 +43,17 @@ node.Parent is CSharpImplicitExpressionBodySyntax ||
             return WriteBlock(node, BlockKindInternal.Statement, base.VisitCSharpCodeBlock);
         }
 
-        public override SyntaxNode VisitCSharpStatement(CSharpStatement node)
+        public override SyntaxNode VisitCSharpStatement(CSharpStatementSyntax node)
         {
             return WriteBlock(node, BlockKindInternal.Statement, base.VisitCSharpStatement);
         }
 
-        public override SyntaxNode VisitCSharpExpression(CSharpExpression node)
+        public override SyntaxNode VisitCSharpExplicitExpression(CSharpExplicitExpressionSyntax node)
         {
-            return WriteBlock(node, BlockKindInternal.Expression, base.VisitCSharpExpression);
+            return WriteBlock(node, BlockKindInternal.Expression, base.VisitCSharpExplicitExpression);
         }
 
-        public override SyntaxNode VisitCSharpImplicitExpression(CSharpImplicitExpression node)
+        public override SyntaxNode VisitCSharpImplicitExpression(CSharpImplicitExpressionSyntax node)
         {
             return WriteBlock(node, BlockKindInternal.Expression, base.VisitCSharpImplicitExpression);
         }

src/Microsoft.AspNetCore.Razor.Language/HtmlNodeOptimizationPass.cs

@@ -22,14 +22,28 @@ public RazorSyntaxTree Execute(RazorCodeDocument codeDocument, RazorSyntaxTree s
                 throw new ArgumentNullException(nameof(syntaxTree));
             }
 
-            var conditionalAttributeCollapser = new ConditionalAttributeCollapser();
+            if (syntaxTree is LegacyRazorSyntaxTree)
+            {
+                return LegacyExecute(codeDocument, syntaxTree);
+            }
+
+            var whitespaceRewriter = new WhitespaceRewriter();
+            var rewritten = whitespaceRewriter.Visit(syntaxTree.Root);
+
+            var rewrittenSyntaxTree = RazorSyntaxTree.Create(rewritten, syntaxTree.Source, syntaxTree.Diagnostics, syntaxTree.Options);
+            return rewrittenSyntaxTree;
+        }
+
+        private RazorSyntaxTree LegacyExecute(RazorCodeDocument codeDocument, RazorSyntaxTree syntaxTree)
+        {
+            var conditionalAttributeCollapser = new LegacyConditionalAttributeCollapser();
             var rewritten = conditionalAttributeCollapser.Rewrite(syntaxTree.LegacyRoot);
 
-            var whitespaceRewriter = new WhiteSpaceRewriter();
+            var whitespaceRewriter = new LegacyWhitespaceRewriter();
             rewritten = whitespaceRewriter.Rewrite(rewritten);
 
             var rewrittenSyntaxTree = RazorSyntaxTree.Create(rewritten, syntaxTree.Source, syntaxTree.Diagnostics, syntaxTree.Options);
             return rewrittenSyntaxTree;
         }
     }
-}
+}

src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpParser.cs

@@ -75,7 +75,7 @@ public CSharpCodeBlockSyntax ParseBlock()
                     else if (At(SyntaxKind.LeftParenthesis))
                     {
                         var expressionBody = ParseExplicitExpressionBody();
-                        var expression = SyntaxFactory.CSharpExpression(transition, expressionBody);
+                        var expression = SyntaxFactory.CSharpExplicitExpression(transition, expressionBody);
                         builder.Add(expression);
                     }
                     else if (At(SyntaxKind.Identifier))
@@ -163,7 +163,7 @@ public CSharpCodeBlockSyntax ParseBlock()
             }
         }
 
-        private CSharpExpressionBodySyntax ParseExplicitExpressionBody()
+        private CSharpExplicitExpressionBodySyntax ParseExplicitExpressionBody()
         {
             var block = new Block(Resources.BlockName_ExplicitExpression, CurrentStart);
             Assert(SyntaxKind.LeftParenthesis);
@@ -214,7 +214,7 @@ private CSharpExpressionBodySyntax ParseExplicitExpressionBody()
                     PutCurrentBack();
                 }
 
-                return SyntaxFactory.CSharpExpressionBody(leftParen, expressionBlock, rightParen);
+                return SyntaxFactory.CSharpExplicitExpressionBody(leftParen, expressionBlock, rightParen);
             }
         }
 

src/Microsoft.AspNetCore.Razor.Language/Legacy/LegacyConditionalAttributeCollapser.cs

@@ -0,0 +1,67 @@
+// 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.Diagnostics;
+using System.Text;
+
+namespace Microsoft.AspNetCore.Razor.Language.Legacy
+{
+    internal class LegacyConditionalAttributeCollapser : MarkupRewriter
+    {
+        protected override bool CanRewrite(Block block)
+        {
+            var generator = block.ChunkGenerator as AttributeBlockChunkGenerator;
+            if (generator != null && block.Children.Count > 0)
+            {
+                // Perf: Avoid allocating an enumerator.
+                for (var i = 0; i < block.Children.Count; i++)
+                {
+                    if (!IsLiteralAttributeValue(block.Children[i]))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
+        {
+            // Collect the content of this node
+            var builder = new StringBuilder();
+            for (var i = 0; i < block.Children.Count; i++)
+            {
+                var childSpan = (Span)block.Children[i];
+                builder.Append(childSpan.Content);
+            }
+
+            // Create a new span containing this content
+            var span = new SpanBuilder(block.Children[0].Start);
+
+            span.EditHandler = SpanEditHandler.CreateDefault(HtmlLanguageCharacteristics.Instance.TokenizeString);
+            Debug.Assert(block.Children.Count > 0);
+            var start = ((Span)block.Children[0]).Start;
+            FillSpan(span, start, builder.ToString());
+            return span.Build();
+        }
+
+        private bool IsLiteralAttributeValue(SyntaxTreeNode node)
+        {
+            if (node.IsBlock)
+            {
+                return false;
+            }
+
+            var span = node as Span;
+            Debug.Assert(span != null);
+
+            return span != null &&
+                (span.ChunkGenerator is LiteralAttributeChunkGenerator ||
+                span.ChunkGenerator is MarkupChunkGenerator ||
+                span.ChunkGenerator == SpanChunkGenerator.Null);
+        }
+    }
+}

src/Microsoft.AspNetCore.Razor.Language/Legacy/LegacyWhitespaceRewriter.cs

@@ -0,0 +1,41 @@
+// 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;
+
+namespace Microsoft.AspNetCore.Razor.Language.Legacy
+{
+    internal class LegacyWhitespaceRewriter : MarkupRewriter
+    {
+        protected override bool CanRewrite(Block block)
+        {
+            return block.Type == BlockKindInternal.Expression && Parent != null;
+        }
+
+        protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
+        {
+            var newBlock = new BlockBuilder(block);
+            newBlock.Children.Clear();
+            var ws = block.Children.FirstOrDefault() as Span;
+            IEnumerable<SyntaxTreeNode> newNodes = block.Children;
+            if (ws.Content.All(char.IsWhiteSpace))
+            {
+                // Add this node to the parent
+                var builder = new SpanBuilder(ws);
+                builder.ClearTokens();
+                FillSpan(builder, ws.Start, ws.Content);
+                parent.Children.Add(builder.Build());
+
+                // Remove the old whitespace node
+                newNodes = block.Children.Skip(1);
+            }
+
+            foreach (SyntaxTreeNode node in newNodes)
+            {
+                newBlock.Children.Add(node);
+            }
+            return newBlock.Build();
+        }
+    }
+}

src/Microsoft.AspNetCore.Razor.Language/Legacy/WhiteSpaceRewriter.cs

@@ -1,41 +1,62 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// 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.Syntax;
 
 namespace Microsoft.AspNetCore.Razor.Language.Legacy
 {
-    internal class WhiteSpaceRewriter : MarkupRewriter
+    internal class WhitespaceRewriter : SyntaxRewriter
     {
-        protected override bool CanRewrite(Block block)
+        public override SyntaxNode Visit(SyntaxNode node)
         {
-            return block.Type == BlockKindInternal.Expression && Parent != null;
+            var children = node.ChildNodes();
+            for (var i = 0; i < children.Count; i++)
+            {
+                var child = children[i];
+                if (child is CSharpCodeBlockSyntax codeBlock &&
+                    TryRewriteWhitespace(codeBlock, out var rewritten, out var whitespaceLiteral))
+                {
+                    // Replace the existing code block with the whitespace literal
+                    // followed by the rewritten code block (with the code whitespace removed).
+                    node = node.ReplaceNode(codeBlock, new SyntaxNode[] { whitespaceLiteral, rewritten });
+                }
+            }
+
+            return base.Visit(node);
         }
 
-        protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
+        private bool TryRewriteWhitespace(CSharpCodeBlockSyntax codeBlock, out CSharpCodeBlockSyntax rewritten, out SyntaxNode whitespaceLiteral)
         {
-            var newBlock = new BlockBuilder(block);
-            newBlock.Children.Clear();
-            var ws = block.Children.FirstOrDefault() as Span;
-            IEnumerable<SyntaxTreeNode> newNodes = block.Children;
-            if (ws.Content.All(char.IsWhiteSpace))
+            // Rewrite any whitespace represented as code at the start of a line preceding an expression block.
+            // We want it to be rendered as Markup.
+
+            rewritten = null;
+            whitespaceLiteral = null;
+            var children = codeBlock.ChildNodes();
+            if (children.Count < 2)
             {
-                // Add this node to the parent
-                var builder = new SpanBuilder(ws);
-                builder.ClearTokens();
-                FillSpan(builder, ws.Start, ws.Content);
-                parent.Children.Add(builder.Build());
-
-                // Remove the old whitespace node
-                newNodes = block.Children.Skip(1);
+                return false;
             }
 
-            foreach (SyntaxTreeNode node in newNodes)
+            if (children[0] is CSharpStatementLiteralSyntax literal &&
+                (children[1] is CSharpExplicitExpressionSyntax || children[1] is CSharpImplicitExpressionSyntax))
             {
-                newBlock.Children.Add(node);
+                var containsNonWhitespace = literal.DescendantNodes()
+                    .Where(n => n.IsToken)
+                    .Cast<SyntaxToken>()
+                    .Any(t => !string.IsNullOrWhiteSpace(t.Content));
+
+                if (!containsNonWhitespace)
+                {
+                    // Literal node is all whitespace. Can rewrite.
+                    whitespaceLiteral = SyntaxFactory.MarkupTextLiteral(literal.LiteralTokens);
+                    rewritten = codeBlock.ReplaceNode(literal, newNode: null);
+                    return true;
+                }
             }
-            return newBlock.Build();
+
+            return false;
         }
     }
 }