Formatting.Analyzers.xml

<?xml version="1.0" encoding="utf-8"?>
<Analyzers>
  <Analyzer Identifier="AddBlankLineAfterEmbeddedStatement">
    <Id>RCS0001</Id>
    <Title>Add blank line after embedded statement.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x)
    Foo(); // [|Id|]
Bar();]]></Before>
        <After><![CDATA[if (x)
    Foo();

Bar();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineAfterRegionDirective">
    <Id>RCS0002</Id>
    <Title>Add blank line after #region.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[class C
{
    #region Methods // [|Id|]
    void M()
    {
    }
    
    #endregion
}]]></Before>
        <After><![CDATA[class C
{
    #region Methods

    void M()
    {
    }
    
    #endregion
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineAfterUsingDirectiveList">
    <Id>RCS0003</Id>
    <Title>Add blank line after using directive list.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[// Copyright ...

using System;
using System.Linq; // [|Id|]
namespace N
{
}]]></Before>
        <After><![CDATA[// Copyright ...

using System;
using System.Linq;

namespace N
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddEmptyLineBeforeClosingBraceOfDoStatement" IsObsolete="true">
    <Id>RCS0004</Id>
    <Title>Add empty line before closing brace of 'do' statement.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[do
{
    Foo(); // [|Id|]
} while (x);]]></Before>
        <After><![CDATA[do
{
    Foo();

} while (x);]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBeforeEndRegionDirective">
    <Id>RCS0005</Id>
    <Title>Add blank line before #endregion.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[class C
{
    #region Methods
    
    void M()
    {
    }
    #endregion // [|Id|]
}]]></Before>
        <After><![CDATA[class C
{
    #region Methods

    void M()
    {
    }
    
    #endregion
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBeforeUsingDirectiveList">
    <Id>RCS0006</Id>
    <Title>Add blank line before using directive list.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[// Copyright ...
using System; // [|Id|]
using System.Linq;

namespace N
{
}]]></Before>
        <After><![CDATA[// Copyright ...

using System;
using System.Linq;

namespace N
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenAccessors">
    <Id>RCS0007</Id>
    <Title>Add blank line between accessors.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string P
{
    get
    {
        return _p;
    } // [|Id|]
    set
    {
        _p = value;
    }
}]]></Before>
        <After><![CDATA[string P
{
    get
    {
        return _p;
    }

    set
    {
        _p = value;
    }
}]]></After>
      </Sample>
    </Samples>
    <Remarks>This rule does not enforce an blank line between two single-line accessors.</Remarks>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenClosingBraceAndNextStatement">
    <Id>RCS0008</Id>
    <Title>Add blank line between closing brace and next statement.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x)
{
} // [|Id|]
Foo();]]></Before>
        <After><![CDATA[if (x)
{
}

Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenDeclarationAndDocumentationComment">
    <Id>RCS0009</Id>
    <Title>Add blank line between declaration and documentation comment.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[object P1 { get; } // [|Id|]
/// <summary>
/// ...
/// </summary>
object P2 { get; }]]></Before>
        <After><![CDATA[object P1 { get; }

/// <summary>
/// ...
/// </summary>
object P2 { get; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenDeclarations">
    <Id>RCS0010</Id>
    <Title>Add blank line between declarations.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[class Foo
{
    void M1()
    {
    } // [|Id|]
    void M2()
    {
    } // [|Id|]
    /// <summary>
    /// ...
    /// </summary>
    void M3()
    {
    } // [|Id|]
    string P1 { get; set; } // [|Id|]
    [Obsolete]
    string P2 { get; set; }
} // [|Id|]
enum Bar
{
    A = 0, // [|Id|]
    /// <summary>
    /// ...
    /// </summary>
    B = 1, // [|Id|]
    [Obsolete]
    C = 2,
}]]></Before>
        <After><![CDATA[class Foo
{
    void M1()
    {
    }

    void M2()
    {
    }

    /// <summary>
    /// ...
    /// </summary>
    void M3()
    {
    }

    string P1 { get; set; }

    [Obsolete]
    string P2 { get; set; }
}

enum Bar
{
    A = 0,

    /// <summary>
    /// ...
    /// </summary>
    B = 1,

    [Obsolete]
    C = 2,
}]]></After>
      </Sample>
    </Samples>
    <Remarks>This rule does not enforce an blank line between two single-line declaration.</Remarks>
  </Analyzer>
  <Analyzer Identifier="BlankLineBetweenSingleLineAccessors">
    <Id>RCS0011</Id>
    <Title>Add/remove blank line between single-line accessors.</Title>
    <MessageFormat>{0} blank line between single-line accessors.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string P
{
    get { return _p; } // [|Id|]
    set { _p = value; }
}]]></Before>
        <After><![CDATA[string P
{
    get { return _p; }
    
    set { _p = value; }
}]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="blank_line_between_single_line_accessors" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="RemoveEmptyLineBetweenSingleLineAccessors">
        <Title>Remove empty line between single-line accessors.</Title>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>blank_line_between_single_line_accessors</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[string P
{
    get { return _p; }
// [|Id|]
    set { _p = value; }
}]]></Before>
            <After><![CDATA[string P
{
    get { return _p; }
    set { _p = value; }
}]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenSingleLineDeclarations">
    <Id>RCS0012</Id>
    <Title>Add blank line between single-line declarations.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[object P1 { get; } // [|Id|]
object P2 { get; }]]></Before>
        <After><![CDATA[object P1 { get; }

object P2 { get; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenSingleLineDeclarationsOfDifferentKind">
    <Id>RCS0013</Id>
    <Title>Add blank line between single-line declarations of different kind.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[object P { get; } // [|Id|]
object this[int index] { get; }]]></Before>
        <After><![CDATA[object P { get; }

object this[int index] { get; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBetweenSwitchSections">
    <Id>RCS0014</Id>
    <Title>Add blank line between switch sections.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <ConfigOptions>
      <Option Key="blank_line_between_closing_brace_and_switch_section" />
    </ConfigOptions>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (x)
{
    case "a":
        return A(); // [|Id|]
    case "b":
        return B();
}
]]></Before>
        <After><![CDATA[switch (x)
{
    case "a":
        return A();

    case "b":
        return B();
}
]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="BlankLineBetweenUsingDirectives">
    <Id>RCS0015</Id>
    <Title>Add/remove blank line between using directives.</Title>
    <MessageFormat>{0} blank line between using directives.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[using System; // [|Id|]
using Microsoft.CodeAnalysis;

namespace N
{
}]]></Before>
        <After><![CDATA[using System;

using Microsoft.CodeAnalysis;

namespace N
{
}]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="blank_line_between_using_directives" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace">
        <Title>Remove empty line between using directives with different root namespace.</Title>
        <MessageFormat>Remove empty line between using directives.</MessageFormat>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>blank_line_between_using_directives</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[using System;
// [|Id|]
using Microsoft.CodeAnalysis;

namespace N
{
}]]></Before>
            <After><![CDATA[using System;
using Microsoft.CodeAnalysis;

namespace N
{
}]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="PutAttributeListOnItsOwnLine">
    <Id>RCS0016</Id>
    <Title>Put attribute list on its own line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[enum Foo
{
    A,
    [Obsolete] B, // [|Id|]
    C,
}]]></Before>
        <After><![CDATA[enum Foo
{
    A,
    [Obsolete]
    B,
    C,
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineAfterBinaryOperatorInsteadOfBeforeIt2" IsObsolete="true">
    <Id>RCS0017</Id>
    <Title>Add new line after binary operator instead of before it.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x
    && y // [|Id|]
    && z)
{
}]]></Before>
        <After><![CDATA[if (x &&
    y &&
    z)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineAfterConditionalOperatorInsteadOfBeforeIt2" IsObsolete="true">
    <Id>RCS0018</Id>
    <Title>Add new line after conditional operator instead of before it.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[var y = (x)
    ? Foo() // [|Id|]
    : Bar();]]></Before>
        <After><![CDATA[var y = (x) ?
     Foo() :
     Bar();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineAfterExpressionBodyArrowInsteadOfBeforeIt2" IsObsolete="true">
    <Id>RCS0019</Id>
    <Title>Add new line after expression body arrow instead of before it.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[object Foo()
    => null; // [|Id|]]]></Before>
        <After><![CDATA[object Foo() =>
    null;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatAccessorBraces">
    <Id>RCS0020</Id>
    <Title>Format accessor's braces on a single line or multiple lines.</Title>
    <MessageFormat>Format braces on {0}.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <ConfigOptions>
      <Option Key="accessor_braces_style" IsRequired="true" />
    </ConfigOptions>
    <Samples>
      <Sample>
        <Before><![CDATA[string Foo
{
    get { return _foo; } // [|Id|]
}]]></Before>
        <After><![CDATA[string Foo
{
    get
    {
        return _foo;
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatBlockBraces">
    <Id>RCS0021</Id>
    <Title>Format block's braces on a single line or multiple lines.</Title>
    <MessageFormat>Format braces on {0}.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <ConfigOptions>
      <Option Key="block_braces_style" IsRequired="true" />
    </ConfigOptions>
    <Samples>
      <Sample>
        <Before><![CDATA[void Foo() { Bar(); }]]></Before>
        <After><![CDATA[void Foo()
{
    Bar();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineAfterOpeningBraceOfEmptyBlock">
    <Id>RCS0022</Id>
    <Title>Add new line after opening brace of empty block.</Title>
    <MessageFormat>([deprecated] Use RCS0021 instead) Format braces on a single line.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[void Foo()
{ } // [|Id|]]]></Before>
        <After><![CDATA[void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatTypeDeclarationBraces">
    <Id>RCS0023</Id>
    <Title>Format type declaration's braces.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[interface IFoo
{ } // [|Id|]]]></Before>
        <After><![CDATA[interface IFoo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineAfterSwitchLabel">
    <Id>RCS0024</Id>
    <Title>Add new line after switch label.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (x)
{
    case "a": return A(); // [|Id|]
    case "b": return B();
}]]></Before>
        <After><![CDATA[switch (x)
{
    case "a":
        return A();
    case "b":
        return B();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PutFullAccessorOnItsOwnLine">
    <Id>RCS0025</Id>
    <Title>Put full accessor on its own line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string Foo { get { return _foo; } set { _foo = value; } }]]></Before>
        <After><![CDATA[string Foo
{
    get { return _foo; }
    set { _foo = value; }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PlaceNewLineAfterOrBeforeBinaryOperator">
    <Id>RCS0027</Id>
    <Title>Place new line after/before binary operator.</Title>
    <MessageFormat>Place new line {0} binary operator.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x && // [|Id|]
    y &&
    z)
{
}]]></Before>
        <After><![CDATA[if (x
    && y
    && z)
{
}]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="binary_operator_new_line" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="AddNewLineAfterBinaryOperatorInsteadOfBeforeIt">
        <Title>Add new line after binary operator instead of before it.</Title>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>binary_operator_new_line</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[if (x
    && y // [|Id|]
    && z)
{
}]]></Before>
            <After><![CDATA[if (x &&
    y &&
    z)
{
}]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="PlaceNewLineAfterOrBeforeConditionalOperator">
    <Id>RCS0028</Id>
    <Title>Place new line after/before '?:' operator.</Title>
    <MessageFormat>Place new line {0} operator.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[var y = x ? // [|Id|]
    Foo() :
    Bar();]]></Before>
        <After><![CDATA[var y = x
    ? Foo()
    : Bar();]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="conditional_operator_new_line" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="AddNewLineAfterConditionalOperatorInsteadOfBeforeIt">
        <Title>Add new line after conditional operator instead of before it.</Title>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>conditional_operator_new_line</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[var y = x
    ? Foo() // [|Id|]
    : Bar();]]></Before>
            <After><![CDATA[var y = x ?
    Foo() :
    Bar();]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="PutConstructorInitializerOnItsOwnLine">
    <Id>RCS0029</Id>
    <Title>Put constructor initializer on its own line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[Foo(object p1, object p2) : base(p1) // [|Id|]
{
    P2 = p2;
}]]></Before>
        <After><![CDATA[Foo(object p1, object p2)
    : base(p1)
{
    P2 = p2;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineBeforeEmbeddedStatement">
    <Id>RCS0030</Id>
    <Title>Add new line before embedded statement.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x) Foo();]]></Before>
        <After><![CDATA[if (x)
    Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PutEnumMemberOnItsOwnLine">
    <Id>RCS0031</Id>
    <Title>Put enum member on its own line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[enum Foo { A, B, C, }]]></Before>
        <After><![CDATA[enum Foo
{
    A,
    B,
    C,
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PlaceNewLineAfterOrBeforeArrowToken">
    <Id>RCS0032</Id>
    <Title>Place new line after/before arrow token.</Title>
    <MessageFormat>Place new line {0} arrow token.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[object Foo() => // [|Id|]
    null;]]></Before>
        <After><![CDATA[object Foo()
    => null;]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="arrow_token_new_line" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="AddNewLineAfterExpressionBodyArrowInsteadOfBeforeIt">
        <Title>Add new line after expression body arrow instead of before it.</Title>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>arrow_token_new_line</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[object Foo()
    => null; // [|Id|]]]></Before>
            <After><![CDATA[object Foo() =>
    null;]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="AddNewLineBeforeStatement">
    <Id>RCS0033</Id>
    <Title>Add new line before statement.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[Foo(); Bar();]]></Before>
        <After><![CDATA[Foo();
Bar();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PutTypeParameterConstraintOnItsOwnLine">
    <Id>RCS0034</Id>
    <Title>Put type parameter constraint on its own line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[class Foo<T1, T2> where T1 : struct where T2 : struct // [|Id|]
{
}]]></Before>
        <After><![CDATA[class Foo<T1, T2>
    where T1 : struct
    where T2 : struct
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyLineBetweenSingleLineAccessors2" IsObsolete="true">
    <Id>RCS0035</Id>
    <Title>Remove empty line between single-line accessors.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string P
{
    get { return _p; }
// [|Id|]
    set { _p = value; }
}]]></Before>
        <After><![CDATA[string P
{
    get { return _p; }
    set { _p = value; }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveBlankLineBetweenSingleLineDeclarationsOfSameKind">
    <Id>RCS0036</Id>
    <Title>Remove blank line between single-line declarations of same kind.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Samples>
        <Sample>
          <Before><![CDATA[object P1 { get; }
// [|Id|]
object P2 { get; }]]></Before>
          <After><![CDATA[object P1 { get; }
object P2 { get; }]]></After>
        </Sample>
      </Samples>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace2" IsObsolete="true">
    <Id>RCS0037</Id>
    <Title>Remove empty line between using directives with different root namespace.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[using System;
// [|Id|]
using Microsoft.CodeAnalysis;

namespace N
{
}]]></Before>
        <After><![CDATA[using System;
using Microsoft.CodeAnalysis;

namespace N
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveBlankLineBetweenUsingDirectivesWithSameRootNamespace">
    <Id>RCS0038</Id>
    <Title>Remove blank line between using directives with same root namespace.</Title>
    <MessageFormat>([deprecated] Use RCS0015 instead) Remove blank line between using directives.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[using System;
// [|Id|]
using System.Linq;

namespace N
{
}]]></Before>
        <After><![CDATA[using System;
using System.Linq;

namespace N
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveNewLineBeforeBaseList">
    <Id>RCS0039</Id>
    <Title>Remove new line before base list.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[class Foo
    : Bar // [|Id|]
{
}]]></Before>
        <After><![CDATA[class Foo : Bar
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveNewLineBetweenClosingBraceAndWhileKeyword2" IsObsolete="true">
    <Id>RCS0040</Id>
    <Title>Remove new line between closing brace and 'while' keyword.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[do
{
    Foo();
} // [|Id|]
while (x);]]></Before>
        <After><![CDATA[do
{
    Foo();
} while (x);]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveNewLineBetweenIfKeywordAndElseKeyword">
    <Id>RCS0041</Id>
    <Title>Remove new line between 'if' keyword and 'else' keyword.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x)
{
    Foo();
}
else // [|Id|]
if (y)
{
    Bar();
}]]></Before>
        <After><![CDATA[if (x)
{
    Foo();
}
else if (y)
{
    Bar();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PutAutoAccessorsOnSingleLine">
    <Id>RCS0042</Id>
    <Title>Put auto-accessors on a single line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string Foo
{ // [|Id|]
    get;
    set;
}]]></Before>
        <After><![CDATA[string Foo { get; set; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatAccessorBracesOnSingleLineWhenExpressionIsOnSingleLine">
    <Id>RCS0043</Id>
    <Title>Format accessor's braces on a single line when expression is on single line.</Title>
    <MessageFormat>([deprecated] Use RCS0020 with option 'roslynator_accessor_braces_style = single_line_when_expression_is_on_single_line) Format braces on a single line.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string Foo
{
    get
    {
        return _foo;
    }
    set
    {
        _foo = value;
    }
}]]></Before>
        <After><![CDATA[string Foo
{
    get { return _foo; }
    set { _foo = value; }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCarriageReturnAndLinefeedAsNewLine">
    <Id>RCS0044</Id>
    <Title>Use carriage return + linefeed as new line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
  </Analyzer>
  <Analyzer Identifier="UseLinefeedAsNewLine">
    <Id>RCS0045</Id>
    <Title>Use linefeed as new line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
  </Analyzer>
  <Analyzer Identifier="UseSpacesInsteadOfTab">
    <Id>RCS0046</Id>
    <Title>Use spaces instead of tab.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
  </Analyzer>
  <Analyzer Identifier="WrapAndIndentEachNodeInList">
    <Id>RCS0047</Id>
    <Title>[deprecated] Wrap and indent each node in list.</Title>
    <MessageFormat>[deprecated] Use analyzer RCS0053 instead.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>This analyzer has been deprecated. Use analyzer [RCS0053](RCS0053.md) instead.</Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[void M(object p1, // [|Id|]
    object p2
    object p3) 
{
}]]></Before>
        <After><![CDATA[void M(
    object p1,
    object p2,
    object p3) 
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[void M(
    object p1, // [|Id|]
    object p2, object p3) 
{
}]]></Before>
        <After><![CDATA[void M(
    object p1,
    object p2,
    object p3) 
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="PutInitializerOnSingleLine">
    <Id>RCS0048</Id>
    <Title>Put initializer on a single line.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[var dic = new Dictionary<int, string>()
{ // [|Id|]
    { 0, "0" }
};]]></Before>
        <After><![CDATA[var dic = new Dictionary<int, string>() { { 0, "0" } };]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineAfterTopComment">
    <Id>RCS0049</Id>
    <Title>Add blank line after top comment.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[// Copyright ...
using System; // [|Id|]

namespace Foo
{
}]]></Before>
        <After><![CDATA[// Copyright ...

using System;

namespace Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBlankLineBeforeTopDeclaration">
    <Id>RCS0050</Id>
    <Title>Add blank line before top declaration.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[using System; // [|Id|]
namespace Foo
{
}]]></Before>
        <After><![CDATA[using System;

namespace Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddOrRemoveNewLineBeforeWhileInDoStatement">
    <Id>RCS0051</Id>
    <Title>Add/remove new line before 'while' in 'do' statement.</Title>
    <MessageFormat>{0} new line before 'while' in 'do' statement.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[do
{
    Foo();
} while (x); // [|Id|]]]></Before>
        <After><![CDATA[do
{
    Foo();
}
while (x);]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="new_line_before_while_in_do_statement" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="RemoveNewLineBetweenClosingBraceAndWhileKeyword">
        <Title>Remove new line between closing brace and 'while' keyword.</Title>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>new_line_before_while_in_do_statement</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[do
{
    Foo();
} // [|Id|]
while (x);]]></Before>
            <After><![CDATA[do
{
    Foo();
} while (x);]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="PlaceNewLineAfterOrBeforeEqualsToken">
    <Id>RCS0052</Id>
    <Title>Place new line after/before equals token.</Title>
    <MessageFormat>Place new line {0} equals token.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = // [|Id|]
    new string(' ', 4);]]></Before>
        <After><![CDATA[string s
    = new string(' ', 4);]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="equals_token_new_line" IsRequired="true" />
    </ConfigOptions>
    <Options>
      <Option Identifier="AddNewLineAfterEqualsSignInsteadOfBeforeIt">
        <Title>Add new line after equals sign instead of before it.</Title>
        <Id>i</Id>
        <OptionKey>invert</OptionKey>
        <NewOptionKey>equals_token_new_line</NewOptionKey>
        <Kind>Invert</Kind>
        <Samples>
          <Sample>
            <Before><![CDATA[string s // [|Id|]
    = new string(' ', 4);]]></Before>
            <After><![CDATA[string s =
    new string(' ', 4);]]></After>
          </Sample>
        </Samples>
      </Option>
    </Options>
  </Analyzer>
  <Analyzer Identifier="FixFormattingOfList">
    <Id>RCS0053</Id>
    <Title>Fix formatting of a list.</Title>
    <MessageFormat>Fix formatting of {0}.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>
      This analyzer:
* fixes indentation of argument/parameter list and similar lists
* formats each item in a multi-line list on a separate line

Following formats are considered as valid (for a parameter list):
```cs
void M(object x, object y)
{
}
```
```cs
void M(
    object x, object y)
{
}
```
```cs
void M(
    object x,
    object y)
{
}
```
</Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[void M(
    object x,
        object y)
{
}]]></Before>
        <After><![CDATA[void M(
    object x,
    object y)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[void M(object x,
    object y)
{
}]]></Before>
        <After><![CDATA[void M(
    object x,
    object y)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[void M(object x,
       object y)
{
}]]></Before>
        <After><![CDATA[void M(
    object x,
    object y)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[void M(
    object x,
    object y, object z)
{
}]]></Before>
        <After><![CDATA[void M(
    object x,
    object y,
    object z)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FixFormattingOfCallChain">
    <Id>RCS0054</Id>
    <Title>Fix formatting of a call chain.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>This analyzer:
* fixes indentation of multi-line call chain
* formats each call on a separate line
</Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[return [|x.M1() // [|Id|]
    .M2().M3()|];]]></Before>
        <After><![CDATA[return [|x.M1()
    .M2()
    .M3()|];]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[return [|x.M1() // [|Id|]
.M2()
.M3()|];]]></Before>
        <After><![CDATA[return [|x.M1()
    .M2()
    .M3()|];]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FixFormattingOfBinaryExpressionChain">
    <Id>RCS0055</Id>
    <Title>Fix formatting of a binary expression chain.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>This analyzer:
 * fixes indentation of multi-line binary expression chain
 * formats each expression on a separate line
 </Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x && y // [|Id|]
    && z)
{
}]]></Before>
        <After><![CDATA[if (x
    && y
    && z)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (x // [|Id|]
&& y
&& z)
{
}]]></Before>
        <After><![CDATA[if (x
    && y
    && z)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="LineIsTooLong">
    <Id>RCS0056</Id>
    <Title>A line is too long.</Title>
    <MessageFormat>A line is too long ({0} characters).</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>This analyzer reports any line that is longer than maximal length.
    
Default maximal length is 140.</Summary>
    <ConfigOptions>
      <Option Key="max_line_length" />
    </ConfigOptions>
  </Analyzer>
  <Analyzer Identifier="NormalizeWhitespaceAtBeginningOfFile">
    <Id>RCS0057</Id>
    <Title>Normalize whitespace at the beginning of a file.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>This analyzer enforces no whitespace at the beginning of a file.</Summary>
  </Analyzer>
  <Analyzer Identifier="NormalizeWhitespaceAtEndOfFile">
    <Id>RCS0058</Id>
    <Title>Normalize whitespace at the end of a file.</Title>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Summary>This analyzer enforces:
* new line at the end of a file
* no new line at the end of a file if the option `roslynator.prefer_new_line_at_end_of_file` is set to `false`.</Summary>
    <ConfigOptions>
      <Option Key="new_line_at_end_of_file" IsRequired="true" />
    </ConfigOptions>
  </Analyzer>
  <Analyzer Identifier="PlaceNewLineAfterOrBeforeNullConditionalOperator">
    <Id>RCS0059</Id>
    <Title>Place new line after/before null-conditional operator.</Title>
    <MessageFormat>Place new line {0} null-conditional operator.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <Samples>
      <Sample>
        <Before><![CDATA[items
    .Select(selector)
    .FirstOrDefault()
    ?.ToString()
    ]]></Before>
        <After><![CDATA[items
    .Select(selector)
    .FirstOrDefault()?
    .ToString()
    ]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="null_conditional_operator_new_line" IsRequired="true" />
    </ConfigOptions>
  </Analyzer>
  <Analyzer Identifier="BlankLineAfterFileScopedNamespaceDeclaration">
    <Id>RCS0060</Id>
    <Title>Add/remove line after file scoped namespace declaration.</Title>
    <MessageFormat>{0} line after file scoped namespace declaration.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <MinLanguageVersion>10.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[namespace A.B // [|Id|]
public class C
{
}]]></Before>
        <After><![CDATA[namespace A.B

public class C
{
}]]></After>
      </Sample>
    </Samples>
    <ConfigOptions>
      <Option Key="blank_line_after_file_scoped_namespace_declaration" IsRequired="true" />
    </ConfigOptions>
    <Links>
      <Link>
        <Url>https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/file-scoped-namespaces</Url>
        <Text>File Scoped Namespaces</Text>
      </Link>
    </Links>
  </Analyzer>
</Analyzers>