public static void ComputeRefactoring(RefactoringContext context, ParameterListSyntax parameterList)
{
if (!SeparatedSyntaxListSelection <ParameterSyntax> .TryCreate(parameterList.Parameters, context.Span, out SeparatedSyntaxListSelection <ParameterSyntax> selection))
{
return;
}
ImmutableArray <ParameterSyntax> parameters = selection
.Where(IsValid)
.ToImmutableArray();
if (!parameters.Any())
{
return;
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.IntroduceAndInitializeProperty))
{
IEnumerable <IntroduceAndInitializePropertyInfo> propertyInfos = parameters
.Select(parameter => new IntroduceAndInitializePropertyInfo(parameter, context.SupportsCSharp6));
var refactoring = new IntroduceAndInitializePropertyRefactoring(propertyInfos);
refactoring.RegisterRefactoring(context);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.IntroduceAndInitializeField))
{
IEnumerable <IntroduceAndInitializeFieldInfo> fieldInfos = parameters
.Select(parameter => new IntroduceAndInitializeFieldInfo(parameter, context.Settings.PrefixFieldIdentifierWithUnderscore));
var refactoring = new IntroduceAndInitializeFieldRefactoring(fieldInfos);
refactoring.RegisterRefactoring(context);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ArgumentListSyntax argumentList)
{
if (!context.IsAnyRefactoringEnabled(
RefactoringDescriptors.AddArgumentName,
RefactoringDescriptors.RemoveArgumentName))
{
return;
}
if (!SeparatedSyntaxListSelection <ArgumentSyntax> .TryCreate(argumentList.Arguments, context.Span, out SeparatedSyntaxListSelection <ArgumentSyntax> selection))
{
return;
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.AddArgumentName))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AddArgumentNameRefactoring.ComputeRefactoring(context, argumentList, selection, semanticModel);
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.RemoveArgumentName))
{
RemoveArgumentNameRefactoring.ComputeRefactoring(context, argumentList, selection);
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration)
{
if (!SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> .TryCreate(enumDeclaration.Members, context.Span, out SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selection))
{
return;
}
if (selection.Count > 1)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SortMemberDeclarations))
{
await SortEnumMemberDeclarationsRefactoring.ComputeRefactoringAsync(context, enumDeclaration, selection).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.GenerateCombinedEnumMember))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
GenerateCombinedEnumMemberRefactoring.ComputeRefactoring(context, enumDeclaration, selection, semanticModel);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveEnumMemberValue))
{
RemoveEnumMemberValueRefactoring.ComputeRefactoring(context, enumDeclaration, selection);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ParameterListSyntax parameterList)
{
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
if (parameters.Any())
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateParameter))
{
var refactoring = new DuplicateParameterRefactoring(parameterList);
refactoring.ComputeRefactoring(context, RefactoringIdentifiers.DuplicateParameter);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CheckParameterForNull) &&
SeparatedSyntaxListSelection <ParameterSyntax> .TryCreate(parameterList.Parameters, context.Span, out SeparatedSyntaxListSelection <ParameterSyntax> selectedParameters))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CheckParameterForNullRefactoring.ComputeRefactoring(context, selectedParameters, semanticModel);
}
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.IntroduceAndInitializeField,
RefactoringIdentifiers.IntroduceAndInitializeProperty))
{
IntroduceAndInitializeRefactoring.ComputeRefactoring(context, parameterList);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatParameterList) &&
(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(parameterList)))
{
if (parameterList.IsSingleLine())
{
if (parameters.Count > 1)
{
context.RegisterRefactoring(
"Format parameters on separate lines",
cancellationToken => SyntaxFormatter.ToMultiLineAsync(context.Document, parameterList, cancellationToken),
RefactoringIdentifiers.FormatParameterList);
}
}
else if (parameterList.DescendantTrivia(parameterList.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.RegisterRefactoring(
"Format parameters on a single line",
cancellationToken => SyntaxFormatter.ToSingleLineAsync(context.Document, parameterList, cancellationToken),
RefactoringIdentifiers.FormatParameterList);
}
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ParameterListSyntax parameterList)
{
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
if (parameters.Any())
{
if (context.IsRefactoringEnabled(RefactoringDescriptors.CopyParameter))
{
var refactoring = new CopyParameterRefactoring(parameterList);
refactoring.ComputeRefactoring(context, RefactoringDescriptors.CopyParameter);
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.CheckParameterForNull) &&
SeparatedSyntaxListSelection <ParameterSyntax> .TryCreate(parameterList.Parameters, context.Span, out SeparatedSyntaxListSelection <ParameterSyntax> selectedParameters))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CheckParameterForNullRefactoring.ComputeRefactoring(context, selectedParameters, semanticModel);
}
if (context.IsAnyRefactoringEnabled(
RefactoringDescriptors.IntroduceAndInitializeField,
RefactoringDescriptors.IntroduceAndInitializeProperty))
{
IntroduceAndInitializeRefactoring.ComputeRefactoring(context, parameterList);
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapParameters) &&
(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(parameterList)))
{
if (parameterList.IsSingleLine())
{
if (parameters.Count > 1)
{
context.RegisterRefactoring(
"Wrap parameters",
ct => SyntaxFormatter.WrapParametersAsync(context.Document, parameterList, ct),
RefactoringDescriptors.WrapParameters);
}
}
else if (parameterList.DescendantTrivia(parameterList.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.RegisterRefactoring(
"Unwrap parameters",
ct => SyntaxFormatter.UnwrapExpressionAsync(context.Document, parameterList, ct),
RefactoringDescriptors.WrapParameters);
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration)
{
if (!SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> .TryCreate(enumDeclaration.Members, context.Span, out SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selection))
{
return;
}
if (selection.Count > 1)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken);
if (enumSymbol?.IsEnumWithFlagsAttribute(semanticModel) == true)
{
object[] constantValues = selection
.Select(f => semanticModel.GetDeclaredSymbol(f, context.CancellationToken))
.Where(f => f.HasConstantValue)
.Select(f => f.ConstantValue)
.ToArray();
object combinedValue = GetCombinedValue(constantValues, enumSymbol);
if (combinedValue != null &&
!IsValueDefined(enumSymbol, combinedValue))
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> enumMembers = enumDeclaration.Members;
string name = NameGenerator.Default.EnsureUniqueEnumMemberName(
string.Concat(selection.Select(f => f.Identifier.ValueText)),
enumSymbol);
EnumMemberDeclarationSyntax newEnumMember = CreateEnumMember(name, selection.SelectedItems);
int insertIndex = selection.EndIndex + 1;
context.RegisterRefactoring(
$"Generate enum member '{name}'",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, newEnumMember, insertIndex, cancellationToken));
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ParameterListSyntax parameterList)
{
if (!SeparatedSyntaxListSelection <ParameterSyntax> .TryCreate(parameterList.Parameters, context.Span, out SeparatedSyntaxListSelection <ParameterSyntax> selection))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ImmutableArray <ParameterSyntax> parameters = selection
.Where(parameter => IsValid(parameter) && CanRefactor(parameter, semanticModel, context.CancellationToken))
.ToImmutableArray();
if (parameters.Length == 1)
{
RegisterRefactoring(context, parameters[0]);
}
else if (parameters.Length > 0)
{
RegisterRefactoring(context, parameters, "parameters");
}
}
