Port roslyn-analyer style rules to experimental rules in roslyn.

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -19,6 +19,10 @@
     <Compile Include="$(MSBuildThisFileDirectory)AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AddRequiredParentheses\CSharpAddRequiredPatternParenthesesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertTypeofToNameof\CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\ConsecutiveBracePlacement\ConsecutiveBracePlacementDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\ConsecutiveStatementPlacement\CSharpConsecutiveStatementPlacementDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\ConstructorInitializerPlacement\ConstructorInitializerPlacementDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\MultipleBlankLines\CSharpMultipleBlankLinesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MatchFolderAndNamespace\CSharpMatchFolderAndNamespaceDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveRedundantEquality\CSharpRemoveRedundantEqualityDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs" />
@@ -105,6 +109,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseSimpleUsingStatement\UseSimpleUsingStatementDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseThrowExpression\CSharpUseThrowExpressionDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ValidateFormatString\CSharpValidateFormatStringDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementDiagnosticAnalyzer.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(DefaultLanguageSourceExtension)' != '' AND '$(BuildingInsideVisualStudio)' != 'true'">
     <ExpectedCompile Include="$(MSBuildThisFileDirectory)**\*$(DefaultLanguageSourceExtension)" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -305,4 +305,13 @@
   <data name="Remove_unnessary_discard" xml:space="preserve">
     <value>Remove unnecessary discard</value>
   </data>
+  <data name="Embedded_statements_must_be_on_their_own_line" xml:space="preserve">
+    <value>Embedded statements must be on their own line</value>
+  </data>
+  <data name="Consecutive_braces_must_not_have_a_blank_between_them" xml:space="preserve">
+    <value>Consecutive braces must not have blank line between them</value>
+  </data>
+  <data name="Blank_line_not_allowed_after_constructor_initializer_colon" xml:space="preserve">
+    <value>Blank line not allowed after constructor initializer colon</value>
+  </data>
 </root>

src/Analyzers/CSharp/Analyzers/NewLines/ConsecutiveBracePlacement/ConsecutiveBracePlacementDiagnosticAnalyzer.cs

@@ -0,0 +1,139 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CSharp.NewLines.ConsecutiveBracePlacement
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class ConsecutiveBracePlacementDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public ConsecutiveBracePlacementDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.ConsecutiveBracePlacementDiagnosticId,
+                   EnforceOnBuildValues.ConsecutiveBracePlacement,
+                   CSharpCodeStyleOptions.AllowBlankLinesBetweenConsecutiveBraces,
+                   LanguageNames.CSharp,
+                   new LocalizableResourceString(
+                       nameof(CSharpAnalyzersResources.Consecutive_braces_must_not_have_a_blank_between_them), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SyntaxTreeWithoutSemanticsAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+            => context.RegisterSyntaxTreeAction(AnalyzeTree);
+
+        private void AnalyzeTree(SyntaxTreeAnalysisContext context)
+        {
+            var option = context.GetOption(CSharpCodeStyleOptions.AllowBlankLinesBetweenConsecutiveBraces);
+            if (option.Value)
+                return;
+
+            using var _ = ArrayBuilder<SyntaxNode>.GetInstance(out var stack);
+            Recurse(context, option.Notification.Severity, stack);
+        }
+
+        private void Recurse(SyntaxTreeAnalysisContext context, ReportDiagnostic severity, ArrayBuilder<SyntaxNode> stack)
+        {
+            var tree = context.Tree;
+            var cancellationToken = context.CancellationToken;
+
+            var root = tree.GetRoot(cancellationToken);
+            var text = tree.GetText(cancellationToken);
+
+            stack.Add(root);
+            while (stack.Count > 0)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var current = stack.Last();
+                stack.RemoveLast();
+
+                // Don't bother analyzing nodes that have syntax errors in them.
+                if (current.ContainsDiagnostics && current.GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error))
+                    continue;
+
+                foreach (var child in current.ChildNodesAndTokens())
+                {
+                    if (child.IsNode)
+                        stack.Add(child.AsNode()!);
+                    else if (child.IsToken)
+                        ProcessToken(context, severity, text, child.AsToken());
+                }
+            }
+        }
+
+        private void ProcessToken(SyntaxTreeAnalysisContext context, ReportDiagnostic severity, SourceText text, SyntaxToken token)
+        {
+            if (!HasExcessBlankLinesAfter(text, token, out var secondBrace, out _))
+                return;
+
+            context.ReportDiagnostic(DiagnosticHelper.Create(
+                this.Descriptor,
+                secondBrace.GetLocation(),
+                severity,
+                additionalLocations: null,
+                properties: null));
+        }
+
+        public static bool HasExcessBlankLinesAfter(
+            SourceText text, SyntaxToken token,
+            out SyntaxToken secondBrace,
+            out SyntaxTrivia endOfLineTrivia)
+        {
+            secondBrace = default;
+            endOfLineTrivia = default;
+            if (!token.IsKind(SyntaxKind.CloseBraceToken))
+                return false;
+
+            var nextToken = token.GetNextToken();
+            if (!nextToken.IsKind(SyntaxKind.CloseBraceToken))
+                return false;
+
+            var firstBrace = token;
+            secondBrace = nextToken;
+
+            // two } tokens.  They need to be on the same line, or if they are not on subsequent lines, then there needs
+            // to be more than whitespace between them.
+            var lines = text.Lines;
+            var firstBraceLine = lines.GetLineFromPosition(firstBrace.SpanStart).LineNumber;
+            var secondBraceLine = lines.GetLineFromPosition(secondBrace.SpanStart).LineNumber;
+
+            var lineCount = secondBraceLine - firstBraceLine;
+
+            // if they're both on the same line, or one line apart, then there's no problem.
+            if (lineCount <= 1)
+                return false;
+
+            // they're multiple lines apart.  This i not ok if those lines are all whitespace.
+            for (var currentLine = firstBraceLine + 1; currentLine < secondBraceLine; currentLine++)
+            {
+                if (!IsAllWhitespace(lines[currentLine]))
+                    return false;
+            }
+
+            endOfLineTrivia = secondBrace.LeadingTrivia.Last(t => t.IsKind(SyntaxKind.EndOfLineTrivia));
+            return endOfLineTrivia != default;
+        }
+
+        private static bool IsAllWhitespace(TextLine textLine)
+        {
+            var text = textLine.Text!;
+            for (var i = textLine.Start; i < textLine.End; i++)
+            {
+                if (!SyntaxFacts.IsWhitespace(text[i]))
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}

src/Analyzers/CSharp/Analyzers/NewLines/ConsecutiveStatementPlacement/CSharpConsecutiveStatementPlacementDiagnosticAnalyzer.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.CSharp.LanguageServices;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.NewLines.ConsecutiveStatementPlacement;
+
+namespace Microsoft.CodeAnalysis.CSharp.NewLines.ConsecutiveStatementPlacement
+{
+    /// <summary>
+    /// Analyzer that finds code of the form:
+    /// <code>
+    /// if (cond)
+    /// {
+    /// }
+    /// NextStatement();
+    /// </code>
+    /// 
+    /// And requires it to be of the form:
+    /// <code>
+    /// if (cond)
+    /// {
+    /// }
+    /// 
+    /// NextStatement();
+    /// </code>
+    /// 
+    /// Specifically, all blocks followed by another statement must have a blank line between them.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class CSharpConsecutiveStatementPlacementDiagnosticAnalyzer : AbstractConsecutiveStatementPlacementDiagnosticAnalyzer<StatementSyntax>
+    {
+        public CSharpConsecutiveStatementPlacementDiagnosticAnalyzer()
+            : base(CSharpSyntaxFacts.Instance)
+        {
+        }
+
+        protected override bool IsBlockLikeStatement(SyntaxNode node)
+            => node is BlockSyntax or SwitchStatementSyntax;
+
+        protected override Location GetDiagnosticLocation(SyntaxNode block)
+            => block.GetLastToken().GetLocation();
+    }
+}

src/Analyzers/CSharp/Analyzers/NewLines/ConstructorInitializerPlacement/ConstructorInitializerPlacementDiagnosticAnalyzer.cs

@@ -0,0 +1,95 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.CSharp.NewLines.ConstructorInitializerPlacement
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class ConstructorInitializerPlacementDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public ConstructorInitializerPlacementDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.ConstructorInitializerPlacementDiagnosticId,
+                   EnforceOnBuildValues.ConsecutiveBracePlacement,
+                   CSharpCodeStyleOptions.AllowBlankLineAfterColonInConstructorInitializer,
+                   LanguageNames.CSharp,
+                   new LocalizableResourceString(
+                       nameof(CSharpAnalyzersResources.Blank_line_not_allowed_after_constructor_initializer_colon), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SyntaxTreeWithoutSemanticsAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+            => context.RegisterSyntaxTreeAction(AnalyzeTree);
+
+        private void AnalyzeTree(SyntaxTreeAnalysisContext context)
+        {
+            var option = context.GetOption(CSharpCodeStyleOptions.AllowBlankLineAfterColonInConstructorInitializer);
+            if (option.Value)
+                return;
+
+            Recurse(context, option.Notification.Severity, context.Tree.GetRoot(context.CancellationToken));
+        }
+
+        private void Recurse(SyntaxTreeAnalysisContext context, ReportDiagnostic severity, SyntaxNode node)
+        {
+            context.CancellationToken.ThrowIfCancellationRequested();
+
+            // Don't bother analyzing nodes that have syntax errors in them.
+            if (node.ContainsDiagnostics)
+                return;
+
+            if (node is ConstructorInitializerSyntax initializer)
+                ProcessConstructorInitializer(context, severity, initializer);
+
+            foreach (var child in node.ChildNodesAndTokens())
+            {
+                if (child.IsNode)
+                    Recurse(context, severity, child.AsNode()!);
+            }
+        }
+
+        private void ProcessConstructorInitializer(
+            SyntaxTreeAnalysisContext context, ReportDiagnostic severity, ConstructorInitializerSyntax initializer)
+        {
+            var sourceText = context.Tree.GetText(context.CancellationToken);
+
+            var colonToken = initializer.ColonToken;
+            var thisOrBaseKeyword = initializer.ThisOrBaseKeyword;
+
+            var colonLine = sourceText.Lines.GetLineFromPosition(colonToken.SpanStart);
+            var thisBaseLine = sourceText.Lines.GetLineFromPosition(thisOrBaseKeyword.SpanStart);
+            if (colonLine == thisBaseLine)
+                return;
+
+            if (colonToken.TrailingTrivia.Count == 0)
+                return;
+
+            if (colonToken.TrailingTrivia.Last().Kind() != SyntaxKind.EndOfLineTrivia)
+                return;
+
+            if (colonToken.TrailingTrivia.Any(t => !t.IsWhitespaceOrEndOfLine()))
+                return;
+
+            if (thisOrBaseKeyword.LeadingTrivia.Any(t => !t.IsWhitespaceOrEndOfLine() && !t.IsSingleOrMultiLineComment()))
+                return;
+
+            context.ReportDiagnostic(DiagnosticHelper.Create(
+                this.Descriptor,
+                colonToken.GetLocation(),
+                severity,
+                additionalLocations: ImmutableArray.Create(initializer.GetLocation()),
+                properties: null));
+        }
+    }
+}