private void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
if (!ifStatement.IsParentKind(SyntaxKind.ElseClause) &&
ifStatement.Else != null)
{
BracesAnalysisResult result = CSharpAnalysis.AnalyzeBraces(ifStatement);
if ((result & BracesAnalysisResult.AddBraces) != 0)
{
context.ReportDiagnostic(DiagnosticDescriptors.AddBracesToIfElseWhenExpressionSpansOverMultipleLines, ifStatement);
}
if ((result & BracesAnalysisResult.RemoveBraces) != 0)
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveBracesFromIfElse, ifStatement);
foreach (SyntaxNode node in ifStatement.DescendantNodes())
{
if (node.IsKind(SyntaxKind.Block))
{
context.ReportBraces(DiagnosticDescriptors.RemoveBracesFromIfElseFadeOut, (BlockSyntax)node);
}
}
}
}
}
private static async Task ChangeTypeAsync(
RefactoringContext context,
VariableDeclarationSyntax variableDeclaration)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeAnalysisFlags flags = CSharpAnalysis.AnalyzeType(variableDeclaration, semanticModel, context.CancellationToken);
if (flags.IsExplicit())
{
if (flags.SupportsImplicit() &&
flags.IsValidSymbol() &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
variableDeclaration.Type,
cancellationToken));
});
}
}
else if (flags.SupportsExplicit() &&
flags.IsValidSymbol() &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(variableDeclaration.Type, context.CancellationToken);
ChangeType(context, variableDeclaration, typeSymbol, semanticModel, context.CancellationToken);
}
}
public static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
IMethodSymbol methodSymbol,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
InvocationExpressionSyntax invocation = SimpleMemberInvocationExpression(expression.WithoutTrailingTrivia(), IdentifierName(methodSymbol.Name))
.WithTrailingTrivia(expression.GetTrailingTrivia());
SyntaxNode newRoot = root.ReplaceNode(expression, invocation);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (methodSymbol.IsExtensionMethod)
{
INamespaceSymbol namespaceSymbol = methodSymbol.ContainingNamespace;
if (namespaceSymbol != null &&
!CSharpAnalysis.IsNamespaceInScope(expression, namespaceSymbol, semanticModel, cancellationToken) &&
newRoot.IsKind(SyntaxKind.CompilationUnit))
{
newRoot = ((CompilationUnitSyntax)newRoot)
.AddUsings(UsingDirective(ParseName(namespaceSymbol.ToString())));
}
}
return(document.WithSyntaxRoot(newRoot));
}
public static void AnalyzeEqualsExpression(SyntaxNodeAnalysisContext context)
{
var equalsExpression = (BinaryExpressionSyntax)context.Node;
ExpressionSyntax left = equalsExpression.Left;
if (left?.IsMissing == false)
{
ExpressionSyntax right = equalsExpression.Right;
if (right?.IsMissing == false)
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
if (CSharpAnalysis.IsEmptyString(left, semanticModel, cancellationToken))
{
if (IsString(right, semanticModel, cancellationToken))
{
ReportDiagnostic(context, equalsExpression);
}
}
else if (CSharpAnalysis.IsEmptyString(right, semanticModel, cancellationToken))
{
if (IsString(left, semanticModel, cancellationToken))
{
ReportDiagnostic(context, equalsExpression);
}
}
}
}
}
private static void AnalyzeBraces(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement)
{
if (!ifStatement.IsParentKind(SyntaxKind.ElseClause) &&
ifStatement.Else != null)
{
BracesAnalysisResult result = CSharpAnalysis.AnalyzeBraces(ifStatement);
if ((result & BracesAnalysisResult.AddBraces) != 0)
{
context.ReportDiagnostic(DiagnosticDescriptors.AddBracesToIfElse, ifStatement);
}
if ((result & BracesAnalysisResult.RemoveBraces) != 0)
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveBracesFromIfElse, ifStatement);
foreach (SyntaxNode node in ifStatement.DescendantNodes())
{
if (node.IsKind(SyntaxKind.Block))
{
context.ReportBraces(DiagnosticDescriptors.RemoveBracesFromIfElseFadeOut, (BlockSyntax)node);
}
}
}
}
}
private static ArgumentSyntax AddParameterName(
ArgumentSyntax argument,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (argument.NameColon == null || argument.NameColon.IsMissing)
{
IParameterSymbol parameterSymbol = CSharpAnalysis.DetermineParameter(
argument,
semanticModel,
allowParams: false,
cancellationToken: cancellationToken);
if (parameterSymbol != null)
{
return(argument
.WithNameColon(
NameColon(parameterSymbol.ToDisplayString(_symbolDisplayFormat))
.WithTrailingSpace())
.WithTriviaFrom(argument));
}
}
return(argument);
}
private static async Task <bool> CanAddParameterNameAsync(
RefactoringContext context,
ImmutableArray <ArgumentSyntax> arguments)
{
foreach (ArgumentSyntax argument in arguments)
{
if (argument.NameColon == null || argument.NameColon.IsMissing)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IParameterSymbol parameterSymbol = CSharpAnalysis.DetermineParameter(
argument,
semanticModel,
allowParams: false,
cancellationToken: context.CancellationToken);
if (parameterSymbol != null)
{
return(true);
}
}
}
return(false);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberAccessExpressionSyntax memberAccess)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddUsingStaticDirective) &&
memberAccess.Expression?.IsMissing == false &&
memberAccess.Name?.IsMissing == false)
{
memberAccess = GetTopmostMemberAccessExpression(memberAccess);
if (context.Span.IsBetweenSpans(memberAccess.Expression))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var typeSymbol = semanticModel.GetSymbol(memberAccess.Expression, context.CancellationToken) as INamedTypeSymbol;
if (typeSymbol.IsStaticClass() &&
(typeSymbol.DeclaredAccessibility == Accessibility.Public || typeSymbol.DeclaredAccessibility == Accessibility.Internal) &&
!CSharpAnalysis.IsStaticClassInScope(memberAccess, typeSymbol, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring($"using static {typeSymbol};",
cancellationToken =>
{
return(RefactorAsync(
context.Document,
typeSymbol.ToString(),
memberAccess,
cancellationToken));
});
}
}
}
}
public static async Task <Document> RefactorAsync(
Document document,
BinaryExpressionSyntax binaryExpression,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax left = binaryExpression.Left;
ExpressionSyntax right = binaryExpression.Right;
BinaryExpressionSyntax newNode = binaryExpression;
if (CSharpAnalysis.IsEmptyString(left, semanticModel, cancellationToken))
{
newNode = binaryExpression
.WithLeft(ZeroLiteralExpression())
.WithRight(CreateConditionalAccess(right));
}
else if (CSharpAnalysis.IsEmptyString(right, semanticModel, cancellationToken))
{
newNode = binaryExpression
.WithLeft(CreateConditionalAccess(left))
.WithRight(ZeroLiteralExpression());
}
else
{
Debug.Assert(false, binaryExpression.ToString());
return(document);
}
newNode = newNode.WithTriviaFrom(binaryExpression).WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(binaryExpression, newNode, cancellationToken).ConfigureAwait(false));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ArgumentSyntax argument)
{
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod))
{
ExpressionSyntax expression = argument.Expression;
if (expression?.IsMissing == false)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(expression).ConvertedType;
if (typeSymbol?.IsErrorType() == false)
{
IEnumerable <ITypeSymbol> newTypes = CSharpAnalysis.DetermineParameterTypes(argument, semanticModel, context.CancellationToken)
.Where(f => !typeSymbol.Equals(f));
ModifyExpressionRefactoring.ComputeRefactoring(context, expression, newTypes, semanticModel);
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceMethodGroupWithLambda))
{
await ReplaceMethodGroupWithLambdaRefactoring.ComputeRefactoringAsync(context, argument).ConfigureAwait(false);
}
}
private void AnalyzeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
var variableDeclaration = (VariableDeclarationSyntax)context.Node;
TypeAnalysisFlags flags = CSharpAnalysis.AnalyzeType(variableDeclaration, context.SemanticModel, context.CancellationToken);
if (flags.IsExplicit())
{
if (flags.SupportsImplicit() &&
flags.IsTypeObvious())
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseVarInsteadOfExplicitTypeWhenTypeIsObvious,
variableDeclaration.Type);
}
}
else if (flags.SupportsExplicit())
{
if (flags.IsTypeObvious())
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarWhenTypeIsObvious,
variableDeclaration.Type);
}
else if (flags.IsValidSymbol())
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarWhenTypeIsNotObvious,
variableDeclaration.Type);
}
}
}
private static void AnalyzeDeclarationExpression(SyntaxNodeAnalysisContext context)
{
var declarationExpression = (DeclarationExpressionSyntax)context.Node;
if (IsFixable(CSharpAnalysis.AnalyzeType(declarationExpression, context.SemanticModel, context.CancellationToken)))
{
context.ReportDiagnostic(DiagnosticDescriptors.UseVarInsteadOfExplicitTypeWhenTypeIsNotObvious, declarationExpression.Type);
}
}
public static async Task ComputeRefactoringsAsync(
RefactoringContext context,
DeclarationExpressionSyntax declarationExpression)
{
if (declarationExpression.Type?.Span.Contains(context.Span) == true &&
context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeExplicitTypeToVar,
RefactoringIdentifiers.ChangeVarToExplicitType))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
switch (CSharpAnalysis.AnalyzeType(
declarationExpression,
semanticModel,
context.CancellationToken))
{
case TypeAnalysisResult.Explicit:
case TypeAnalysisResult.ExplicitButShouldBeImplicit:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
declarationExpression.Type,
cancellationToken));
});
}
break;
}
case TypeAnalysisResult.Implicit:
case TypeAnalysisResult.ImplicitButShouldBeExplicit:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
TypeSyntax type = declarationExpression.Type;
var localSymbol = semanticModel.GetDeclaredSymbol(declarationExpression.Designation, context.CancellationToken) as ILocalSymbol;
ITypeSymbol typeSymbol = localSymbol.Type;
context.RegisterRefactoring(
$"Change type to '{SymbolDisplay.GetMinimalDisplayString(typeSymbol, type.Span.Start, semanticModel)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken));
}
break;
}
}
}
}
private static ExpressionSyntax ParenthesizeIfNecessary(this ExpressionSyntax expression, SyntaxKind kind)
{
if (expression != null &&
CSharpAnalysis.GetOperatorPrecedence(expression) > CSharpAnalysis.GetOperatorPrecedence(kind))
{
expression = expression.Parenthesize(moveTrivia: true);
}
return(expression);
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxKind kind, ExpressionSyntax expression)
{
if (expression != null &&
GetGroupNumber(kind) == GetGroupNumber(expression.Kind()) &&
CSharpAnalysis.GetOperatorPrecedence(expression) < CSharpAnalysis.GetOperatorPrecedence(kind))
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddParenthesesAccordingToOperatorPrecedence,
expression);
}
}
private static ExpressionSyntax ParenthesizeIfNecessary(ExpressionSyntax expression, SyntaxKind parentKind)
{
if (CSharpAnalysis.GetOperatorPrecedence(expression) > CSharpAnalysis.GetOperatorPrecedence(parentKind))
{
return(expression.Parenthesize(moveTrivia: true));
}
else
{
return(expression);
}
}
private static void AnalyzeForEachStatement(SyntaxNodeAnalysisContext context)
{
var forEachStatement = (ForEachStatementSyntax)context.Node;
TypeAnalysisFlags flags = CSharpAnalysis.AnalyzeType(forEachStatement, context.SemanticModel);
if (flags.IsExplicit() &&
flags.SupportsImplicit())
{
context.ReportDiagnostic(DiagnosticDescriptors.UseVarInsteadOfExplicitTypeInForEach, forEachStatement.Type);
}
}
private void AnalyzeForEachStatement(SyntaxNodeAnalysisContext context)
{
var forEachStatement = (ForEachStatementSyntax)context.Node;
TypeAnalysisResult result = CSharpAnalysis.AnalyzeType(forEachStatement, context.SemanticModel, context.CancellationToken);
if (result == TypeAnalysisResult.ImplicitButShouldBeExplicit)
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarInForEach,
forEachStatement.Type);
}
}
private void AnalyzeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
var variableDeclaration = (VariableDeclarationSyntax)context.Node;
switch (CSharpAnalysis.AnalyzeType(variableDeclaration, context.SemanticModel, context.CancellationToken))
{
case TypeAnalysisResult.Explicit:
{
break;
}
case TypeAnalysisResult.ExplicitButShouldBeImplicit:
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseVarInsteadOfExplicitType,
variableDeclaration.Type.GetLocation());
break;
}
case TypeAnalysisResult.Implicit:
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarEvenIfObvious,
variableDeclaration.Type.GetLocation());
break;
}
case TypeAnalysisResult.ImplicitButShouldBeExplicit:
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVar,
variableDeclaration.Type.GetLocation());
break;
}
}
}
internal static async Task ChangeTypeAsync(
RefactoringContext context,
ForEachStatementSyntax forEachStatement)
{
TypeSyntax type = forEachStatement.Type;
if (type?.Span.Contains(context.Span) != true)
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeAnalysisResult result = CSharpAnalysis.AnalyzeType(
forEachStatement,
semanticModel,
context.CancellationToken);
if (result == TypeAnalysisResult.Explicit)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeToVarAsync(context.Document, type, cancellationToken));
}
}
else if (result == TypeAnalysisResult.ImplicitButShouldBeExplicit)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
context.RegisterRefactoring(
$"Change type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, type.Span.Start)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken));
}
}
}
private static List <ParameterInfo> GetParameterInfos(
ArgumentListSyntax argumentList,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var list = new List <ParameterInfo>();
foreach (ArgumentSyntax argument in argumentList.Arguments)
{
IParameterSymbol parameterSymbol = CSharpAnalysis.DetermineParameter(argument, semanticModel, cancellationToken: cancellationToken);
if (parameterSymbol != null)
{
list.Add(new ParameterInfo(parameterSymbol, argument.Expression));
}
else
{
return(null);
}
}
return(list);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IdentifierNameSyntax identifierName)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamespaceSymbol namespaceSymbol = null;
SyntaxNode node = identifierName;
SyntaxNode prevNode = null;
while (node?.Parent?.IsKind(SyntaxKind.QualifiedName, SyntaxKind.AliasQualifiedName, SyntaxKind.SimpleMemberAccessExpression) == true)
{
ISymbol symbol = semanticModel.GetSymbol(node, context.CancellationToken);
if (symbol?.IsNamespace() == true)
{
namespaceSymbol = (INamespaceSymbol)symbol;
prevNode = node;
node = node.Parent;
}
else
{
break;
}
}
node = prevNode;
if (node?.IsParentKind(SyntaxKind.QualifiedName, SyntaxKind.AliasQualifiedName, SyntaxKind.SimpleMemberAccessExpression) == true &&
!node.IsDescendantOf(SyntaxKind.UsingDirective) &&
!CSharpAnalysis.IsNamespaceInScope(node, namespaceSymbol, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
$"using {namespaceSymbol};",
cancellationToken => RefactorAsync(context.Document, node, namespaceSymbol, cancellationToken));
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation)
{
ExpressionSyntax expression = invocation.Expression;
if (expression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == true)
{
var memberAccess = (MemberAccessExpressionSyntax)expression;
ArgumentListSyntax argumentList = invocation.ArgumentList;
if (argumentList != null)
{
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
if (arguments.Any())
{
SimpleNameSyntax name = memberAccess.Name;
if (name?.Identifier.ValueText == "Join")
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
MethodInfo info = semanticModel.GetMethodInfo(invocation, cancellationToken);
if (info.IsValid &&
info.HasName("Join") &&
info.IsContainingType(SpecialType.System_String) &&
info.IsPublic &&
info.IsStatic &&
info.IsReturnType(SpecialType.System_String) &&
!info.IsGenericMethod &&
!info.IsExtensionMethod)
{
ImmutableArray <IParameterSymbol> parameters = info.Parameters;
if (parameters.Length == 2 &&
parameters[0].Type.IsString())
{
IParameterSymbol parameter = parameters[1];
if (parameter.IsParamsOf(SpecialType.System_String) ||
parameter.IsParamsOf(SpecialType.System_Object) ||
parameter.Type.IsConstructedFromIEnumerableOfT())
{
ArgumentSyntax firstArgument = arguments.First();
ExpressionSyntax argumentExpression = firstArgument.Expression;
if (argumentExpression != null &&
CSharpAnalysis.IsEmptyString(argumentExpression, semanticModel, cancellationToken) &&
!invocation.ContainsDirectives(TextSpan.FromBounds(invocation.SpanStart, firstArgument.Span.End)))
{
context.ReportDiagnostic(
DiagnosticDescriptors.CallStringConcatInsteadOfStringJoin,
name);
}
}
}
}
}
}
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SwitchSectionSyntax switchSection)
{
if (SelectedStatementsRefactoring.IsAnyRefactoringEnabled(context))
{
StatementContainerSelection selectedStatements;
if (StatementContainerSelection.TryCreate(switchSection, context.Span, out selectedStatements))
{
await SelectedStatementsRefactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitSwitchLabels))
{
SplitSwitchLabelsRefactoring.ComputeRefactoring(context, switchSection);
}
if (context.Span.IsEmpty &&
context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.AddBracesToSwitchSection,
RefactoringIdentifiers.AddBracesToSwitchSections,
RefactoringIdentifiers.RemoveBracesFromSwitchSection,
RefactoringIdentifiers.RemoveBracesFromSwitchSections))
{
var switchStatement = (SwitchStatementSyntax)switchSection.Parent;
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
switch (CSharpAnalysis.AnalyzeBraces(switchSection))
{
case BracesAnalysisResult.AddBraces:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSection))
{
context.RegisterRefactoring(
AddBracesToSwitchSectionRefactoring.Title,
cancellationToken => AddBracesToSwitchSectionRefactoring.RefactorAsync(context.Document, switchSection, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSections) &&
sections.Any(f => f != switchSection && AddBracesToSwitchSectionRefactoring.CanAddBraces(f)))
{
context.RegisterRefactoring(
AddBracesToSwitchSectionsRefactoring.Title,
cancellationToken => AddBracesToSwitchSectionsRefactoring.RefactorAsync(context.Document, switchStatement, null, cancellationToken));
}
break;
}
case BracesAnalysisResult.RemoveBraces:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSection))
{
context.RegisterRefactoring(
RemoveBracesFromSwitchSectionRefactoring.Title,
cancellationToken => RemoveBracesFromSwitchSectionRefactoring.RefactorAsync(context.Document, switchSection, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSections) &&
sections.Any(f => f != switchSection && RemoveBracesFromSwitchSectionRefactoring.CanRemoveBraces(f)))
{
context.RegisterRefactoring(
RemoveBracesFromSwitchSectionsRefactoring.Title,
cancellationToken => RemoveBracesFromSwitchSectionsRefactoring.RefactorAsync(context.Document, switchStatement, null, cancellationToken));
}
break;
}
}
}
}
public static void ComputeRefactorings(RefactoringContext context, SwitchStatementSyntax switchStatement)
{
bool fRemoveStatements = context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveStatementsFromSwitchSections);
bool fAddBraces = context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSections);
bool fRemoveBraces = context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSections);
if (fRemoveStatements || fAddBraces || fRemoveBraces)
{
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
if (sections.Any())
{
var selectedSections = new SelectedNodeCollection <SwitchSectionSyntax>(sections, context.Span);
if (selectedSections.Any())
{
if (fAddBraces || fRemoveBraces)
{
var addBraces = new List <SwitchSectionSyntax>();
var removeBraces = new List <SwitchSectionSyntax>();
foreach (SwitchSectionSyntax section in selectedSections)
{
if (addBraces.Count > 0 &&
removeBraces.Count > 0)
{
break;
}
switch (CSharpAnalysis.AnalyzeBraces(section))
{
case BracesAnalysisResult.AddBraces:
{
addBraces.Add(section);
break;
}
case BracesAnalysisResult.RemoveBraces:
{
removeBraces.Add(section);
break;
}
}
}
if (fAddBraces && addBraces.Count > 0)
{
string title = AddBracesToSwitchSectionRefactoring.Title;
if (addBraces.Count > 1)
{
title += "s";
}
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(AddBracesToSwitchSectionsRefactoring.RefactorAsync(
context.Document,
switchStatement,
addBraces.ToArray(),
cancellationToken));
});
}
if (fRemoveBraces && removeBraces.Count > 0)
{
string title = RemoveBracesFromSwitchSectionRefactoring.Title;
if (removeBraces.Count > 1)
{
title += "s";
}
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(RemoveBracesFromSwitchSectionsRefactoring.RefactorAsync(
context.Document,
switchStatement,
removeBraces.ToArray(),
cancellationToken));
});
}
}
if (fRemoveStatements)
{
string title = "Remove statements from section";
if (selectedSections.IsMultiple)
{
title += "s";
}
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(RemoveStatementsFromSwitchSectionsRefactoring.RefactorAsync(
context.Document,
switchStatement,
selectedSections.ToImmutableArray(),
cancellationToken));
});
}
}
}
}
}
