private void Analyze(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var lambda = (ParenthesizedLambdaExpressionSyntax)context.Node;
ParameterListSyntax parameterList = lambda.ParameterList;
if (parameterList != null)
{
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
if (parameters.Count == 1)
{
ParameterSyntax parameter = parameters[0];
if (parameter.Modifiers.Count == 0 &&
parameter.AttributeLists.Count == 0 &&
parameter.Default == null)
{
Analyze(context, parameterList);
}
}
else if (parameters.Count > 1)
{
if (parameters.All(parameter => parameter.Modifiers.Count == 0 &&
parameter.AttributeLists.Count == 0 &&
parameter.Default == null &&
parameter.Type?.IsMissing == false))
{
Analyze(context, parameterList);
}
}
}
}
public static void ComputeRefactoring(
RefactoringContext context,
EnumDeclarationSyntax enumDeclaration,
SemanticModel semanticModel)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
if (!members.Any())
{
return;
}
if (members.All(f => f.EqualsValue?.Value == null))
{
return;
}
INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken);
bool isFlags = enumSymbol.HasAttribute(MetadataNames.System_FlagsAttribute);
if (!AreNewValuesDifferentFromExistingValues())
{
return;
}
Document document = context.Document;
context.RegisterRefactoring(
"Declare explicit values (overwrite existing values)",
ct => RefactorAsync(document, enumDeclaration, enumSymbol, semanticModel, ct),
EquivalenceKey);
bool AreNewValuesDifferentFromExistingValues()
{
ulong value = 0;
foreach (EnumMemberDeclarationSyntax member in enumDeclaration.Members)
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(member, context.CancellationToken);
EnumFieldSymbolInfo fieldSymbolInfo = EnumFieldSymbolInfo.Create(fieldSymbol);
if (!fieldSymbolInfo.HasValue)
{
return(true);
}
if (isFlags &&
fieldSymbolInfo.HasCompositeValue())
{
continue;
}
if (value != fieldSymbolInfo.Value)
{
return(true);
}
if (isFlags)
{
value = (value == 0) ? 1 : value * 2;
}
else
{
value++;
}
if (!ConvertHelpers.CanConvertFromUInt64(value, enumSymbol.EnumUnderlyingType.SpecialType))
{
return(false);
}
}
return(false);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, InitializerExpressionSyntax initializer)
{
if (initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) &&
initializer.IsParentKind(SyntaxKind.CollectionInitializerExpression))
{
initializer = (InitializerExpressionSyntax)initializer.Parent;
}
if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(initializer) ||
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(initializer.Expressions))
{
SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions;
if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapInitializerExpressions) &&
expressions.Any() &&
!initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) &&
initializer.IsParentKind(
SyntaxKind.ArrayCreationExpression,
SyntaxKind.ImplicitArrayCreationExpression,
SyntaxKind.ObjectCreationExpression,
SyntaxKind.CollectionInitializerExpression,
SyntaxKind.WithExpression))
{
if (initializer.IsSingleLine(includeExteriorTrivia: false))
{
context.RegisterRefactoring(
"Wrap initializer expression",
ct => SyntaxFormatter.ToMultiLineAsync(context.Document, initializer, ct),
RefactoringDescriptors.WrapInitializerExpressions);
}
else if (expressions.All(expression => expression.IsSingleLine()) &&
initializer.DescendantTrivia(initializer.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.RegisterRefactoring(
"Unwrap initializer expressions",
ct => SyntaxFormatter.ToSingleLineAsync(
context.Document,
initializer.Parent,
TextSpan.FromBounds(initializer.OpenBraceToken.GetPreviousToken().Span.End, initializer.CloseBraceToken.Span.End),
ct),
RefactoringDescriptors.WrapInitializerExpressions);
}
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.AddAllPropertiesToInitializer) &&
initializer.IsKind(SyntaxKind.ObjectInitializerExpression, SyntaxKind.WithInitializerExpression) &&
AddAllPropertiesToInitializerRefactoring.IsApplicableSpan(initializer, context.Span))
{
SemanticModel semanticModdel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AddAllPropertiesToInitializerRefactoring.ComputeRefactorings(context, initializer, semanticModdel);
}
await ExpandInitializerRefactoring.ComputeRefactoringsAsync(context, initializer).ConfigureAwait(false);
if (context.IsRefactoringEnabled(RefactoringDescriptors.UseIndexInitializer) &&
context.SupportsCSharp6)
{
await UseIndexInitializerRefactoring.ComputeRefactoringAsync(context, initializer).ConfigureAwait(false);
}
}
}
