public static ConditionalExpressionParenthesesStyle GetConditionalExpressionParenthesesStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.ConditionalOperatorConditionParenthesesStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.ConditionalOperatorConditionParenthesesStyle_Include, StringComparison.OrdinalIgnoreCase))
{
return(ConditionalExpressionParenthesesStyle.Include);
}
else if (string.Equals(rawValue, ConfigOptionValues.ConditionalOperatorConditionParenthesesStyle_Omit, StringComparison.OrdinalIgnoreCase))
{
return(ConditionalExpressionParenthesesStyle.Omit);
}
else if (string.Equals(rawValue, ConfigOptionValues.ConditionalOperatorConditionParenthesesStyle_OmitWhenConditionIsSingleToken, StringComparison.OrdinalIgnoreCase))
{
return(ConditionalExpressionParenthesesStyle.OmitWhenConditionIsSingleToken);
}
}
if (configOptions.IsEnabled(LegacyConfigOptions.RemoveParenthesesFromConditionOfConditionalExpressionWhenExpressionIsSingleToken))
{
return(ConditionalExpressionParenthesesStyle.OmitWhenConditionIsSingleToken);
}
return(ConditionalExpressionParenthesesStyle.None);
}
public static ArrayCreationTypeStyle GetArrayCreationTypeStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.ArrayCreationTypeStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.ArrayCreationTypeStyle_Implicit, StringComparison.OrdinalIgnoreCase))
{
return(ArrayCreationTypeStyle.Implicit);
}
else if (string.Equals(rawValue, ConfigOptionValues.ArrayCreationTypeStyle_Explicit, StringComparison.OrdinalIgnoreCase))
{
return(ArrayCreationTypeStyle.Explicit);
}
else if (string.Equals(rawValue, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious, StringComparison.OrdinalIgnoreCase))
{
return(ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious);
}
}
if (context.IsEnabled(LegacyConfigOptions.UseImplicitlyTypedArrayWhenTypeIsObvious))
{
return(ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious);
}
if (context.IsEnabled(LegacyConfigOptions.UseImplicitlyTypedArray))
{
return(ArrayCreationTypeStyle.Implicit);
}
return(ArrayCreationTypeStyle.None);
}
public static bool?GetBlankLineBetweenClosingBraceAndSwitchSection(this SyntaxNodeAnalysisContext context)
{
if (ConfigOptions.TryGetValueAsBool(context.GetConfigOptions(), ConfigOptions.BlankLineBetweenClosingBraceAndSwitchSection, out bool value))
{
return(value);
}
if (context.TryGetOptionAsBool(LegacyConfigOptions.RemoveEmptyLineBetweenClosingBraceAndSwitchSection, out value))
{
return(!value);
}
return(null);
}
public static bool?GetSuppressUnityScriptMethods(this SyntaxNodeAnalysisContext context)
{
if (ConfigOptions.TryGetValueAsBool(context.GetConfigOptions(), ConfigOptions.SuppressUnityScriptMethods, out bool value))
{
return(value);
}
if (context.TryGetOptionAsBool(LegacyConfigOptions.SuppressUnityScriptMethods, out value))
{
return(value);
}
return(null);
}
public static ConfigureAwaitStyle GetConfigureAwaitStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValueAsBool(configOptions, ConfigOptions.ConfigureAwait, out bool value))
{
return((value) ? ConfigureAwaitStyle.Include : ConfigureAwaitStyle.Omit);
}
if (configOptions.IsEnabled(LegacyConfigOptions.RemoveCallToConfigureAwait))
{
return(ConfigureAwaitStyle.Omit);
}
return(ConfigureAwaitStyle.None);
}
public static NewLineStyle GetNewLineBeforeWhileInDoStatement(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValueAsBool(configOptions, ConfigOptions.NewLineBeforeWhileInDoStatement, out bool addNewLine))
{
return((addNewLine) ? NewLineStyle.Add : NewLineStyle.Remove);
}
if (configOptions.TryGetValueAsBool(LegacyConfigOptions.RemoveNewLineBetweenClosingBraceAndWhileKeyword, out bool removeLine))
{
return((removeLine) ? NewLineStyle.Remove : NewLineStyle.Add);
}
return(NewLineStyle.None);
}
public static BlankLineStyle GetBlankLineBetweenSingleLineAccessors(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValueAsBool(configOptions, ConfigOptions.BlankLineBetweenSingleLineAccessors, out bool addLine))
{
return((addLine) ? BlankLineStyle.Add : BlankLineStyle.Remove);
}
if (ConfigOptions.TryGetValueAsBool(configOptions, LegacyConfigOptions.RemoveEmptyLineBetweenSingleLineAccessors, out bool removeLine))
{
return((removeLine) ? BlankLineStyle.Remove : BlankLineStyle.Add);
}
return(BlankLineStyle.None);
}
public static DocCommentSummaryStyle GetDocCommentSummaryStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.DocCommentSummaryStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.DocCommentSummaryStyle_MultiLine, StringComparison.OrdinalIgnoreCase))
{
return(DocCommentSummaryStyle.MultiLine);
}
else if (string.Equals(rawValue, ConfigOptionValues.DocCommentSummaryStyle_SingleLine, StringComparison.OrdinalIgnoreCase))
{
return(DocCommentSummaryStyle.SingleLine);
}
}
return(DocCommentSummaryStyle.None);
}
public static BlockBracesStyle GetBlockBracesStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.BlockBracesStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.BlockBracesStyle_MultiLine, StringComparison.OrdinalIgnoreCase))
{
return(BlockBracesStyle.MultiLine);
}
else if (string.Equals(rawValue, ConfigOptionValues.BlockBracesStyle_SingleLineWhenEmpty, StringComparison.OrdinalIgnoreCase))
{
return(BlockBracesStyle.SingleLineWhenEmpty);
}
}
return(BlockBracesStyle.None);
}
public static BodyStyle Create(SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
var option = BodyStyleOption.None;
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.BodyStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.BodyStyle_Block, StringComparison.OrdinalIgnoreCase))
{
option = BodyStyleOption.Block;
}
else if (string.Equals(rawValue, ConfigOptionValues.BodyStyle_Expression, StringComparison.OrdinalIgnoreCase))
{
option = BodyStyleOption.Expression;
}
}
else if (configOptions.TryGetValueAsBool(LegacyConfigOptions.ConvertExpressionBodyToBlockBody, out bool useBlockBody))
{
option = (useBlockBody) ? BodyStyleOption.Block : BodyStyleOption.Expression;
}
bool?useBlockBodyWhenDeclarationIsMultiLine = null;
if (ConfigOptions.GetValueAsBool(configOptions, ConfigOptions.UseBlockBodyWhenDeclarationSpansOverMultipleLines) == true ||
configOptions.IsEnabled(LegacyConfigOptions.ConvertExpressionBodyToBlockBodyWhenDeclarationIsMultiLine))
{
useBlockBodyWhenDeclarationIsMultiLine = true;
}
bool?useBlockBodyWhenExpressionIsMultiline = null;
if (ConfigOptions.GetValueAsBool(configOptions, ConfigOptions.UseBlockBodyWhenExpressionSpansOverMultipleLines) == true ||
configOptions.IsEnabled(LegacyConfigOptions.ConvertExpressionBodyToBlockBodyWhenExpressionIsMultiLine))
{
useBlockBodyWhenExpressionIsMultiline = true;
}
return(new BodyStyle(option, useBlockBodyWhenDeclarationIsMultiLine, useBlockBodyWhenExpressionIsMultiline));
}
public static ObjectCreationTypeStyle GetObjectCreationTypeStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.ObjectCreationTypeStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationTypeStyle_Implicit, StringComparison.OrdinalIgnoreCase))
{
return(ObjectCreationTypeStyle.Implicit);
}
else if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationTypeStyle_Explicit, StringComparison.OrdinalIgnoreCase))
{
return(ObjectCreationTypeStyle.Explicit);
}
else if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious, StringComparison.OrdinalIgnoreCase))
{
return(ObjectCreationTypeStyle.ImplicitWhenTypeIsObvious);
}
}
return(ObjectCreationTypeStyle.None);
}
public static bool?PreferAnonymousFunctionOrMethodGroup(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.UseAnonymousFunctionOrMethodGroup, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.UseAnonymousFunctionOrMethodGroup_AnonymousFunction, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
else if (string.Equals(rawValue, ConfigOptionValues.UseAnonymousFunctionOrMethodGroup_MethodGroup, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
}
if (configOptions.IsEnabled(LegacyConfigOptions.ConvertMethodGroupToAnonymousFunction))
{
return(true);
}
return(null);
}
public static EnumFlagOperationStyle GetEnumHasFlagStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.EnumHasFlagStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.EnumHasFlagStyle_Method, StringComparison.OrdinalIgnoreCase))
{
return(EnumFlagOperationStyle.HasFlagMethod);
}
else if (string.Equals(rawValue, ConfigOptionValues.EnumHasFlagStyle_Operator, StringComparison.OrdinalIgnoreCase))
{
return(EnumFlagOperationStyle.BitwiseOperator);
}
}
if (configOptions.IsEnabled(LegacyConfigOptions.ConvertBitwiseOperationToHasFlagCall))
{
return(EnumFlagOperationStyle.HasFlagMethod);
}
return(EnumFlagOperationStyle.None);
}
public static UsingDirectiveBlankLineStyle GetBlankLineBetweenUsingDirectives(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.BlankLineBetweenUsingDirectives, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.BlankLineBetweenUsingDirectives_Never, StringComparison.OrdinalIgnoreCase))
{
return(UsingDirectiveBlankLineStyle.Never);
}
else if (string.Equals(rawValue, ConfigOptionValues.BlankLineBetweenUsingDirectives_SeparateGroups, StringComparison.OrdinalIgnoreCase))
{
return(UsingDirectiveBlankLineStyle.SeparateGroups);
}
}
if (ConfigOptions.TryGetValueAsBool(configOptions, LegacyConfigOptions.RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace, out bool removeLine))
{
return((removeLine) ? UsingDirectiveBlankLineStyle.Never : UsingDirectiveBlankLineStyle.SeparateGroups);
}
return(UsingDirectiveBlankLineStyle.None);
}
public static AccessibilityModifierStyle GetAccessModifiersStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.AccessibilityModifiers, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.AccessibilityModifiers_Explicit, StringComparison.OrdinalIgnoreCase))
{
return(AccessibilityModifierStyle.Explicit);
}
else if (string.Equals(rawValue, ConfigOptionValues.AccessibilityModifiers_Implicit, StringComparison.OrdinalIgnoreCase))
{
return(AccessibilityModifierStyle.Implicit);
}
}
if (ConfigOptions.TryGetValueAsBool(configOptions, LegacyConfigOptions.RemoveAccessibilityModifiers, out bool useImplicit))
{
return((useImplicit) ? AccessibilityModifierStyle.Implicit : AccessibilityModifierStyle.Explicit);
}
return(AccessibilityModifierStyle.None);
}
public static ObjectCreationParenthesesStyle GetObjectCreationParenthesesStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.ObjectCreationParenthesesStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationParenthesesStyle_Include, StringComparison.OrdinalIgnoreCase))
{
return(ObjectCreationParenthesesStyle.Include);
}
else if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationParenthesesStyle_Omit, StringComparison.OrdinalIgnoreCase))
{
return(ObjectCreationParenthesesStyle.Omit);
}
}
if (context.IsEnabled(LegacyConfigOptions.RemoveParenthesesWhenCreatingNewObject))
{
return(ObjectCreationParenthesesStyle.Omit);
}
return(ObjectCreationParenthesesStyle.None);
}
public static EmptyStringStyle GetEmptyStringStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.EmptyStringStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.EmptyStringStyle_Field, StringComparison.OrdinalIgnoreCase))
{
return(EmptyStringStyle.Field);
}
if (string.Equals(rawValue, ConfigOptionValues.EmptyStringStyle_Literal, StringComparison.OrdinalIgnoreCase))
{
return(EmptyStringStyle.Literal);
}
}
if (configOptions.IsEnabled(LegacyConfigOptions.UseStringEmptyInsteadOfEmptyStringLiteral))
{
return(EmptyStringStyle.Field);
}
return(EmptyStringStyle.None);
}
public static NullCheckStyle GetNullCheckStyle(this SyntaxNodeAnalysisContext context)
{
AnalyzerConfigOptions configOptions = context.GetConfigOptions();
if (ConfigOptions.TryGetValue(configOptions, ConfigOptions.NullCheckStyle, out string rawValue))
{
if (string.Equals(rawValue, ConfigOptionValues.NullCheckStyle_EqualityOperator, StringComparison.OrdinalIgnoreCase))
{
return(NullCheckStyle.EqualityOperator);
}
if (string.Equals(rawValue, ConfigOptionValues.NullCheckStyle_PatternMatching, StringComparison.OrdinalIgnoreCase))
{
return(NullCheckStyle.PatternMatching);
}
}
if (configOptions.IsEnabled(LegacyConfigOptions.UseComparisonInsteadPatternMatchingToCheckForNull))
{
return(NullCheckStyle.EqualityOperator);
}
return(NullCheckStyle.None);
}
private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
{
var topBinaryExpression = (BinaryExpressionSyntax)context.Node;
SyntaxKind binaryKind = topBinaryExpression.Kind();
if (topBinaryExpression.IsParentKind(binaryKind))
{
return;
}
if (topBinaryExpression.IsSingleLine(includeExteriorTrivia: false))
{
return;
}
int?indentationLength = null;
BinaryExpressionSyntax binaryExpression = topBinaryExpression;
while (true)
{
context.CancellationToken.ThrowIfCancellationRequested();
ExpressionSyntax left = binaryExpression.Left;
SyntaxToken token = binaryExpression.OperatorToken;
SyntaxTriviaList leftTrailing = left.GetTrailingTrivia();
SyntaxTriviaList tokenTrailing = token.TrailingTrivia;
if (IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(leftTrailing))
{
if (Analyze(token))
{
return;
}
}
else if (IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(tokenTrailing))
{
if (Analyze(binaryExpression.Right))
{
return;
}
}
else if (leftTrailing.IsEmptyOrWhitespace() &&
tokenTrailing.IsEmptyOrWhitespace())
{
ReportDiagnostic();
return;
}
if (!left.IsKind(binaryKind))
{
break;
}
binaryExpression = (BinaryExpressionSyntax)left;
}
bool Analyze(SyntaxNodeOrToken nodeOrToken)
{
SyntaxTriviaList.Reversed.Enumerator en = nodeOrToken.GetLeadingTrivia().Reverse().GetEnumerator();
if (!en.MoveNext())
{
if ((indentationLength ??= GetIndentationLength()) == -1)
{
return(true);
}
ReportDiagnostic();
return(true);
}
switch (en.Current.Kind())
{
case SyntaxKind.WhitespaceTrivia:
{
if ((indentationLength ??= GetIndentationLength()) == -1)
{
return(true);
}
if (en.Current.Span.Length != indentationLength)
{
if (!en.MoveNext() ||
en.Current.IsEndOfLineTrivia())
{
if (topBinaryExpression.FindTrivia(nodeOrToken.FullSpan.Start - 1).IsEndOfLineTrivia())
{
ReportDiagnostic();
return(true);
}
}
break;
}
break;
}
case SyntaxKind.EndOfLineTrivia:
{
if (topBinaryExpression.FindTrivia(nodeOrToken.FullSpan.Start - 1).IsEndOfLineTrivia())
{
if ((indentationLength ??= GetIndentationLength()) == -1)
{
return(true);
}
ReportDiagnostic();
return(true);
}
break;
}
}
return(false);
}
int GetIndentationLength()
{
IndentationAnalysis indentationAnalysis = AnalyzeIndentation(topBinaryExpression);
if (indentationAnalysis.IndentSize == 0)
{
return(-1);
}
SyntaxTriviaList leadingTrivia = topBinaryExpression.GetLeadingTrivia();
if (leadingTrivia.Any() &&
leadingTrivia.Last() == indentationAnalysis.Indentation &&
context.GetConfigOptions().GetBinaryOperatorNewLinePosition() == NewLinePosition.After)
{
return(indentationAnalysis.IndentationLength);
}
else
{
return(indentationAnalysis.IncreasedIndentationLength);
}
}
void ReportDiagnostic()
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.FixFormattingOfBinaryExpressionChain,
topBinaryExpression);
}
}
public static NewLinePosition GetNullConditionalOperatorNewLinePosition(this SyntaxNodeAnalysisContext context, NewLinePosition defaultValue = NewLinePosition.None)
{
return(context.GetConfigOptions().GetNullConditionalOperatorNewLinePosition(defaultValue));
}
public static NewLinePosition GetBinaryExpressionNewLinePosition(this SyntaxNodeAnalysisContext context)
{
return(context.GetConfigOptions().GetBinaryOperatorNewLinePosition());
}
public static NewLinePosition GetArrowTokenNewLinePosition(this SyntaxNodeAnalysisContext context)
{
return(context.GetConfigOptions().GetArrowTokenNewLinePosition());
}
public static bool?PreferNewLineAtEndOfFile(this SyntaxNodeAnalysisContext context)
{
return(context.GetConfigOptions().PreferNewLineAtEndOfFile());
}
public static bool?UseVarInsteadOfImplicitObjectCreation(this SyntaxNodeAnalysisContext context)
{
return(ConfigOptions.GetValueAsBool(context.GetConfigOptions(), ConfigOptions.UseVarInsteadOfImplicitObjectCreation));
}
public static EnumFlagValueStyle GetEnumFlagValueStyle(this SyntaxNodeAnalysisContext context)
{
return(GetEnumFlagValueStyle(context.GetConfigOptions()));
}
public static InfiniteLoopStyle GetInfiniteLoopStyle(this SyntaxNodeAnalysisContext context)
{
return(GetInfiniteLoopStyle(context.GetConfigOptions()));
}
