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

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -19,6 +19,9 @@
     <Compile Include="$(MSBuildThisFileDirectory)AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AddRequiredParentheses\CSharpAddRequiredPatternParenthesesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertTypeofToNameof\CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\ConsecutiveBracePlacement\CSharpConsecutiveBracePlacementDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\ConsecutiveStatementPlacement\CSharpConsecutiveStatementPlacementDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\MultipleBlankLines\CSharpMultipleBlankLinesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveRedundantEquality\CSharpRemoveRedundantEqualityDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs" />
@@ -103,6 +106,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)UseSimpleUsingStatement\UseSimpleUsingStatementDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseThrowExpression\CSharpUseThrowExpressionDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ValidateFormatString\CSharpValidateFormatStringDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NewLines\WrapEmbeddedStatement\CSharpWrapEmbeddedStatementDiagnosticAnalyzer.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(DefaultLanguageSourceExtension)' != '' AND '$(BuildingInsideVisualStudio)' != 'true'">
     <ExpectedCompile Include="$(MSBuildThisFileDirectory)**\*$(DefaultLanguageSourceExtension)" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -305,4 +305,10 @@
   <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>
 </root>

src/Analyzers/CSharp/Analyzers/NewLines/ConsecutiveBracePlacement/CSharpConsecutiveBracePlacementDiagnosticAnalyzer.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 CSharpConsecutiveBracePlacementDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public CSharpConsecutiveBracePlacementDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.ConsecutiveBracePlacementDiagnosticId,
+                   EnforceOnBuildValues.ConsecutiveBracePlacement,
+                   CSharpCodeStyleOptions.DisallowBlankLinesBetweenConsecutiveBraces,
+                   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.DisallowBlankLinesBetweenConsecutiveBraces);
+            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.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>
+    {
+        protected override bool IsEndOfLine(SyntaxTrivia trivia)
+            => trivia.Kind() == SyntaxKind.EndOfLineTrivia;
+
+        protected override bool IsWhitespace(SyntaxTrivia trivia)
+            => trivia.Kind() == SyntaxKind.WhitespaceTrivia;
+
+        protected override bool IsBlockStatement(SyntaxNode node)
+            => node is BlockSyntax || node is SwitchStatementSyntax;
+
+        protected override Location GetDiagnosticLocation(SyntaxNode block)
+            => block.GetLastToken().GetLocation();
+    }
+}

src/Analyzers/CSharp/Analyzers/NewLines/MultipleBlankLines/CSharpMultipleBlankLinesDiagnosticAnalyzer.cs

@@ -0,0 +1,16 @@
+// 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.Diagnostics;
+using Microsoft.CodeAnalysis.NewLines.MultipleBlankLines;
+
+namespace Microsoft.CodeAnalysis.CSharp.NewLines.MultipleBlankLines
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class CSharpMultipleBlankLinesDiagnosticAnalyzer : AbstractMultipleBlankLinesDiagnosticAnalyzer
+    {
+        protected override bool IsEndOfLine(SyntaxTrivia trivia)
+            => trivia.IsKind(SyntaxKind.EndOfLineTrivia);
+    }
+}

src/Analyzers/CSharp/Analyzers/NewLines/WrapEmbeddedStatement/CSharpWrapEmbeddedStatementDiagnosticAnalyzer.cs

@@ -0,0 +1,135 @@
+// 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.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.CSharp.NewLines.WrapEmbeddedStatement
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class CSharpWrapEmbeddedStatementDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public CSharpWrapEmbeddedStatementDiagnosticAnalyzer()
+            : base(IDEDiagnosticIds.WrapEmbeddedStatementDiagnosticId,
+                   EnforceOnBuildValues.WrapEmbeddedStatement,
+                   CSharpCodeStyleOptions.DisallowEmbeddedStatementsOnSameLine,
+                   LanguageNames.CSharp,
+                   new LocalizableResourceString(
+                       nameof(CSharpAnalyzersResources.Embedded_statements_must_be_on_their_own_line), 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.DisallowEmbeddedStatementsOnSameLine);
+            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;
+
+            // Report on the topmost statement that has an issue.  No need to recurse further at that point. Note: the
+            // fixer will fix up all statements, but we don't want to clutter things with lots of diagnostics on the
+            // same line.
+            if (node is StatementSyntax statement &&
+                CheckStatementSyntax(context, severity, statement))
+            {
+                return;
+            }
+
+            foreach (var child in node.ChildNodesAndTokens())
+            {
+                if (child.IsNode)
+                    Recurse(context, severity, child.AsNode()!);
+            }
+        }
+
+        private bool CheckStatementSyntax(SyntaxTreeAnalysisContext context, ReportDiagnostic severity, StatementSyntax statement)
+        {
+            if (!StatementNeedsWrapping(statement))
+                return false;
+
+            var additionalLocations = ImmutableArray.Create(statement.GetLocation());
+            context.ReportDiagnostic(DiagnosticHelper.Create(
+                this.Descriptor,
+                statement.GetFirstToken().GetLocation(),
+                severity,
+                additionalLocations,
+                properties: null));
+            return true;
+        }
+
+        public static bool StatementNeedsWrapping(StatementSyntax statement)
+        {
+            // Statement has to be parented by another statement (or an else-clause) to count.
+            var parent = statement.Parent;
+            var parentIsElseClause = parent.IsKind(SyntaxKind.ElseClause);
+
+            if (!(parent is StatementSyntax || parentIsElseClause))
+                return false;
+
+            // `else if` is always allowed.
+            if (statement.IsKind(SyntaxKind.IfStatement) && parentIsElseClause)
+                return false;
+
+            var statementStartToken = statement.GetFirstToken();
+
+            // we have to have a newline between the start of this statement and the previous statement.
+            if (ContainsEndOfLineBetween(statementStartToken.GetPreviousToken(), statementStartToken))
+                return false;
+
+            // Looks like a statement that might need wrapping.  However, we do suppress wrapping for a few well known
+            // acceptable cases.
+
+            if (parent.IsKind(SyntaxKind.Block))
+            {
+                // Blocks can be on a single line if parented by a member/accessor/lambda.
+                // And if they only contain a single statement at most within them.
+                var blockParent = parent.Parent;
+                if (blockParent is MemberDeclarationSyntax or
+                    AccessorDeclarationSyntax or
+                    AnonymousFunctionExpressionSyntax)
+                {
+                    if (parent.DescendantNodes().OfType<StatementSyntax>().Count() <= 1)
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool ContainsEndOfLineBetween(SyntaxToken previous, SyntaxToken next)
+            => ContainsEndOfLine(previous.TrailingTrivia) || ContainsEndOfLine(next.LeadingTrivia);
+
+        private static bool ContainsEndOfLine(SyntaxTriviaList triviaList)
+        {
+            foreach (var trivia in triviaList)
+            {
+                if (trivia.IsKind(SyntaxKind.EndOfLineTrivia))
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}