Add NoNewLineAfterOpenBraceRule and formatting for DisabledTextTrivia

Lakshmi Priya Sekar · Lakshmi Priya Sekar · commit 7ba96d708788 · 2014-11-04T19:24:44.000-08:00
diff --git a/src/CodeFormatter/CodeFormatter.csproj b/src/CodeFormatter/CodeFormatter.csproj
@@ -32,12 +32,48 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Microsoft.CodeAnalysis.Workspaces">
+    <Reference Include="Microsoft.CodeAnalysis, Version=0.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.CodeAnalysis.Common.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.CSharp, Version=0.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.CodeAnalysis.CSharp.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.CSharp.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.CSharp.Desktop">
+      <HintPath>..\packages\Microsoft.CodeAnalysis.CSharp.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.CSharp.Desktop.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.CSharp.Workspaces">
+      <HintPath>..\packages\Microsoft.CodeAnalysis.CSharp.Workspaces.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.CSharp.Workspaces.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.Desktop, Version=0.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.CodeAnalysis.Common.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.Desktop.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.VisualBasic">
+      <HintPath>..\packages\Microsoft.CodeAnalysis.VisualBasic.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.VisualBasic.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.VisualBasic.Desktop">
+      <HintPath>..\packages\Microsoft.CodeAnalysis.VisualBasic.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.VisualBasic.Desktop.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.VisualBasic.Workspaces">
+      <HintPath>..\packages\Microsoft.CodeAnalysis.VisualBasic.Workspaces.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.VisualBasic.Workspaces.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.Workspaces, Version=0.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\Microsoft.CodeAnalysis.Workspaces.Common.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.Workspaces.dll</HintPath>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.Collections.Immutable, Version=1.1.20.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.Bcl.Immutable.1.1.20-beta\lib\portable-net45+win8\System.Collections.Immutable.dll</HintPath>
+    </Reference>
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Reflection.Metadata, Version=1.0.12.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.Bcl.Metadata.1.0.12-alpha\lib\portable-net45+win8\System.Reflection.Metadata.dll</HintPath>
+    </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -50,6 +86,7 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Microsoft.DotNet.CodeFormatting\Microsoft.DotNet.CodeFormatting.csproj">
diff --git a/src/CodeFormatter/Program.cs b/src/CodeFormatter/Program.cs
@@ -32,6 +32,7 @@ private static int Main(string[] args)
             Console.CancelKeyPress += delegate { cts.Cancel(); };
 
             RunAsnc(solutionPath, ct).Wait(ct);
+            Console.WriteLine("Completed formatting.");
             return 0;
         }
 
diff --git a/src/CodeFormatter/packages.config b/src/CodeFormatter/packages.config
@@ -0,0 +1,9 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.Bcl.Immutable" version="1.1.20-beta" targetFramework="net45" />
+  <package id="Microsoft.Bcl.Metadata" version="1.0.12-alpha" targetFramework="net45" />
+  <package id="Microsoft.CodeAnalysis.Common" version="0.7.4091001-beta" targetFramework="net45" />
+  <package id="Microsoft.CodeAnalysis.VisualBasic" version="0.7.4091001-beta" targetFramework="net45" />
+  <package id="Microsoft.CodeAnalysis.VisualBasic.Workspaces" version="0.7.4091001-beta" targetFramework="net45" />
+  <package id="Microsoft.CodeAnalysis.Workspaces.Common" version="0.7.4091001-beta" targetFramework="net45" />
+</packages>
diff --git a/src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs b/src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs
@@ -37,11 +37,12 @@ public async Task<bool> RunAsync(Workspace workspace, CancellationToken cancella
                 var shouldBeProcessed = await ShouldBeProcessedAsync(document);
                 if (!shouldBeProcessed)
                     continue;
-
+                
                 var newDocument = await RewriteDocumentAsync(document, cancellationToken);
                 hasChanges |= newDocument != document;
 
                 await SaveDocumentAsync(newDocument, cancellationToken);
+                Console.WriteLine("Processing document: " + document.Name);
             }
 
             return hasChanges;
@@ -84,11 +85,18 @@ private async Task<Document> RewriteDocumentAsync(Document document, Cancellatio
                 foreach (var rule in _rules)
                     newDocument = await rule.ProcessAsync(newDocument, cancellationToken);
 
-                if (newDocument == previousDocument)
+                if (IsEqual(newDocument, previousDocument))
                     break;
             }
 
             return newDocument;
         }
+
+        private bool IsEqual(Document newDocument, Document previousDocument)
+        {
+            if (newDocument.GetTextAsync().Result.ToString() == previousDocument.GetTextAsync().Result.ToString())
+                return true;
+            return false;
+        }
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj b/src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj
@@ -47,6 +47,9 @@
     <Reference Include="Microsoft.CodeAnalysis.Desktop">
       <HintPath>..\packages\Microsoft.CodeAnalysis.Common.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.Desktop.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.CodeAnalysis.VisualBasic">
+      <HintPath>..\packages\Microsoft.CodeAnalysis.VisualBasic.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.VisualBasic.dll</HintPath>
+    </Reference>
     <Reference Include="Microsoft.CodeAnalysis.Workspaces">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\Microsoft.CodeAnalysis.Workspaces.Common.0.7.4091001-beta\lib\net45\Microsoft.CodeAnalysis.Workspaces.dll</HintPath>
@@ -76,6 +79,7 @@
     <Compile Include="Filters\IgnoreDesignerGeneratedCodeFilter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Rules\HasCopyrightHeaderFormattingRule.cs" />
+    <Compile Include="Rules\HasNoNewLineAfterOpenBraceFormattingRule.cs" />
     <Compile Include="Rules\HasNoXmlBasedCopyrightHeaderFormattingRule.cs" />
     <Compile Include="Rules\HasUsingsOutsideOfNamespaceFormattingRule.cs" />
     <Compile Include="Rules\IsFormattedFormattingRule.cs" />
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoNewLineAfterOpenBraceFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoNewLineAfterOpenBraceFormattingRule.cs
@@ -0,0 +1,44 @@
+﻿// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under MIT. See LICENSE in the project root for license information.
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Microsoft.DotNet.CodeFormatting.Rules
+{
+    [Export(typeof(IFormattingRule))]
+    internal sealed class HasNoNewLineAfterOpenBraceFormattingRule : IFormattingRule
+    {
+        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        {
+            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
+            if (syntaxRoot == null)
+                return document;
+
+            var openBraceTokens = syntaxRoot.DescendantTokens().Where((token) => token.CSharpKind() == SyntaxKind.OpenBraceToken);
+            Func<SyntaxToken, SyntaxToken, SyntaxToken> replacementForTokens = (token, dummy) =>
+            {
+                var triviaItem = token.LeadingTrivia.First();
+                int elementsToRemove = 1;
+                while (triviaItem == token.LeadingTrivia.ElementAt(elementsToRemove))
+                    elementsToRemove++;
+                var newToken = token.WithLeadingTrivia(token.LeadingTrivia.Skip(elementsToRemove));
+                return newToken;
+            };
+
+            var tokensToReplace = openBraceTokens.Where((token) =>
+            {
+                var nextToken = token.GetNextToken();
+                return (nextToken.HasLeadingTrivia && nextToken.LeadingTrivia.First().CSharpKind() == SyntaxKind.EndOfLineTrivia);         
+            }).Select((token) => token.GetNextToken());
+
+            return document.WithSyntaxRoot(syntaxRoot.ReplaceTokens(tokensToReplace, replacementForTokens));
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/IsFormattedFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/IsFormattedFormattingRule.cs
@@ -7,15 +7,29 @@
 
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.CSharp;
+using System.Linq;
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
     [Export(typeof(IFormattingRule))]
     internal sealed class IsFormattedFormattingRule : IFormattingRule
     {
-        public Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
         {
-            return Formatter.FormatAsync(document, cancellationToken: cancellationToken);
+            // Roslyn formatter doesn't format code in #if false as it's considered as DisabledTextTrivia. Will be removed after the bug is fixed.
+            // Doing that manually here
+            var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
+            var oldTrivia = syntaxRoot.DescendantTrivia().Where(trivia => trivia.CSharpKind() == SyntaxKind.DisabledTextTrivia);
+            Func<SyntaxTrivia, SyntaxTrivia, SyntaxTrivia> replacementTrivia = (trivia, dummy) =>
+            {
+                var compilation = SyntaxFactory.ParseCompilationUnit(trivia.ToString());
+                var formattedTrivia = Formatter.Format(compilation.SyntaxTree.GetRoot(), document.Project.Solution.Workspace).GetText().ToString();
+                return SyntaxFactory.DisabledText(formattedTrivia);
+            };
+
+            var newDocument = document.WithSyntaxRoot(syntaxRoot.ReplaceTrivia(oldTrivia, replacementTrivia));
+            return await Formatter.FormatAsync(newDocument, cancellationToken: cancellationToken);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ private static int Main(string[] args)`
`32`	`32`	`Console.CancelKeyPress += delegate { cts.Cancel(); };`
`33`	`33`
`34`	`34`	`RunAsnc(solutionPath, ct).Wait(ct);`
	`35`	`+ Console.WriteLine("Completed formatting.");`
`35`	`36`	`return 0;`
`36`	`37`	`}`
`37`	`38`
Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,12 @@ public async Task<bool> RunAsync(Workspace workspace, CancellationToken cancella`
`37`	`37`	`var shouldBeProcessed = await ShouldBeProcessedAsync(document);`
`38`	`38`	`if (!shouldBeProcessed)`
`39`	`39`	`continue;`
`40`		`-`
	`40`	`+`
`41`	`41`	`var newDocument = await RewriteDocumentAsync(document, cancellationToken);`
`42`	`42`	`hasChanges \|= newDocument != document;`
`43`	`43`
`44`	`44`	`await SaveDocumentAsync(newDocument, cancellationToken);`
	`45`	`+ Console.WriteLine("Processing document: " + document.Name);`
`45`	`46`	`}`
`46`	`47`
`47`	`48`	`return hasChanges;`
`@@ -84,11 +85,18 @@ private async Task<Document> RewriteDocumentAsync(Document document, Cancellatio`
`84`	`85`	`foreach (var rule in _rules)`
`85`	`86`	`newDocument = await rule.ProcessAsync(newDocument, cancellationToken);`
`86`	`87`
`87`		`- if (newDocument == previousDocument)`
	`88`	`+ if (IsEqual(newDocument, previousDocument))`
`88`	`89`	`break;`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`return newDocument;`
`92`	`93`	`}`
	`94`	`+`
	`95`	`+ private bool IsEqual(Document newDocument, Document previousDocument)`
	`96`	`+ {`
	`97`	`+ if (newDocument.GetTextAsync().Result.ToString() == previousDocument.GetTextAsync().Result.ToString())`
	`98`	`+ return true;`
	`99`	`+ return false;`
	`100`	`+ }`
`93`	`101`	`}`
`94`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,29 @@`
`7`	`7`
`8`	`8`	`using Microsoft.CodeAnalysis;`
`9`	`9`	`using Microsoft.CodeAnalysis.Formatting;`
	`10`	`+using Microsoft.CodeAnalysis.CSharp;`
	`11`	`+using System.Linq;`
`10`	`12`
`11`	`13`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`12`	`14`	`{`
`13`	`15`	`[Export(typeof(IFormattingRule))]`
`14`	`16`	`internal sealed class IsFormattedFormattingRule : IFormattingRule`
`15`	`17`	`{`
`16`		`- public Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
	`18`	`+ public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)`
`17`	`19`	`{`
`18`		`- return Formatter.FormatAsync(document, cancellationToken: cancellationToken);`
	`20`	`+ // Roslyn formatter doesn't format code in #if false as it's considered as DisabledTextTrivia. Will be removed after the bug is fixed.`
	`21`	`+ // Doing that manually here`
	`22`	`+ var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;`
	`23`	`+ var oldTrivia = syntaxRoot.DescendantTrivia().Where(trivia => trivia.CSharpKind() == SyntaxKind.DisabledTextTrivia);`
	`24`	`+ Func<SyntaxTrivia, SyntaxTrivia, SyntaxTrivia> replacementTrivia = (trivia, dummy) =>`
	`25`	`+ {`
	`26`	`+ var compilation = SyntaxFactory.ParseCompilationUnit(trivia.ToString());`
	`27`	`+ var formattedTrivia = Formatter.Format(compilation.SyntaxTree.GetRoot(), document.Project.Solution.Workspace).GetText().ToString();`
	`28`	`+ return SyntaxFactory.DisabledText(formattedTrivia);`
	`29`	`+ };`
	`30`	`+`
	`31`	`+ var newDocument = document.WithSyntaxRoot(syntaxRoot.ReplaceTrivia(oldTrivia, replacementTrivia));`
	`32`	`+ return await Formatter.FormatAsync(newDocument, cancellationToken: cancellationToken);`
`19`	`33`	`}`
`20`	`34`	`}`
`21`	`35`	`}`