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 = InvocationExpression(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 &&
!SyntaxUtility.IsUsingDirectiveInScope(expression, namespaceSymbol, semanticModel, cancellationToken) &&
newRoot.IsKind(SyntaxKind.CompilationUnit))
{
newRoot = ((CompilationUnitSyntax)newRoot)
.AddUsings(UsingDirective(ParseName(namespaceSymbol.ToString())));
}
}
return(document.WithSyntaxRoot(newRoot));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberAccessExpressionSyntax memberAccess)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddUsingStaticDirective) &&
memberAccess.Expression?.IsMissing == false &&
memberAccess.Name?.IsMissing == false &&
context.SupportsSemanticModel)
{
memberAccess = GetTopmostMemberAccessExpression(memberAccess);
if (context.Span.IsBetweenSpans(memberAccess.Expression))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var typeSymbol = semanticModel
.GetSymbolInfo(memberAccess.Expression, context.CancellationToken)
.Symbol as INamedTypeSymbol;
if (typeSymbol?.IsStaticClass() == true &&
(typeSymbol.IsPublic() || typeSymbol.IsInternal()) &&
!SyntaxUtility.IsUsingStaticDirectiveInScope(memberAccess, typeSymbol, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring($"using static {typeSymbol.ToString()};",
cancellationToken =>
{
return(RefactorAsync(
context.Document,
typeSymbol.ToString(),
memberAccess,
cancellationToken));
});
}
}
}
}
private static ConditionalExpressionSyntax CreateMultilineConditionalExpression(ConditionalExpressionSyntax conditionalExpression)
{
SyntaxTriviaList triviaList = SyntaxUtility.GetIndentTrivia(conditionalExpression.Parent).Add(CSharpFactory.IndentTrivia());
triviaList = triviaList.Insert(0, CSharpFactory.NewLineTrivia());
ParenthesizedExpressionSyntax condition = null;
if (conditionalExpression.Condition.IsKind(SyntaxKind.ParenthesizedExpression))
{
condition = (ParenthesizedExpressionSyntax)conditionalExpression.Condition;
}
else
{
condition = ParenthesizedExpression(conditionalExpression.Condition.WithoutTrailingTrivia())
.WithCloseParenToken(CreateTokenWithTrailingNewLine(SyntaxKind.CloseParenToken));
}
return(ConditionalExpression(
condition.WithoutTrailingTrivia(),
conditionalExpression.WhenTrue.WithoutTrailingTrivia(),
conditionalExpression.WhenFalse.WithoutTrailingTrivia())
.WithQuestionToken(CreateToken(SyntaxKind.QuestionToken, triviaList))
.WithColonToken(CreateToken(SyntaxKind.ColonToken, triviaList)));
}
internal static async Task RenameIdentifierAccordingToTypeNameAsync(
RefactoringContext context,
ForEachStatementSyntax forEachStatement)
{
if (forEachStatement.Type != null &&
forEachStatement.Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
string oldName = forEachStatement.Identifier.ValueText;
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(forEachStatement.Type, context.CancellationToken).Type;
if (typeSymbol?.IsErrorType() == false)
{
string newName = SyntaxUtility.CreateIdentifier(
typeSymbol,
firstCharToLower: true);
if (!string.IsNullOrEmpty(newName) &&
!string.Equals(newName, oldName, StringComparison.Ordinal))
{
ISymbol symbol = semanticModel.GetDeclaredSymbol(forEachStatement, context.CancellationToken);
context.RegisterRefactoring(
$"Rename variable to '{newName}'",
cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken));
}
}
}
}
private static IfRefactoring CreateIfToAssignmentWithWithCoalesceExpression(
IfStatementSyntax ifStatement,
ExpressionSyntax left,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
NullCheckExpression nullCheck,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (nullCheck.Kind == NullCheckKind.EqualsToNull ||
nullCheck.Kind == NullCheckKind.NotEqualsToNull)
{
if (SyntaxComparer.AreEquivalent(nullCheck.Expression, expression1, requireNotNull: true))
{
return(new IfElseToAssignmentWithCoalesceExpression(ifStatement, left, expression1, expression2));
}
}
if (expression1.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
SyntaxUtility.IsPropertyOfNullableOfT(expression1, "Value", semanticModel, cancellationToken))
{
expression1 = ((MemberAccessExpressionSyntax)expression1).Expression;
if (SyntaxComparer.AreEquivalent(nullCheck.Expression, expression1, requireNotNull: true))
{
return(new IfElseToAssignmentWithCoalesceExpression(ifStatement, left, expression1, expression2));
}
}
return(null);
}
private static InitializerExpressionSyntax GetMultilineInitializer(InitializerExpressionSyntax initializer)
{
SyntaxNode parent = initializer.Parent;
if (parent.IsKind(SyntaxKind.ObjectCreationExpression) &&
!initializer.IsKind(SyntaxKind.CollectionInitializerExpression))
{
return(initializer
.WithExpressions(
SeparatedList(
initializer.Expressions.Select(expression => expression.WithLeadingTrivia(CSharpFactory.NewLineTrivia()))))
.WithFormatterAnnotation());
}
SyntaxTriviaList indent = SyntaxUtility.GetIndentTrivia(initializer);
SyntaxTriviaList indent2 = indent.Add(CSharpFactory.IndentTrivia());
indent = indent.Insert(0, CSharpFactory.NewLineTrivia());
indent2 = indent2.Insert(0, CSharpFactory.NewLineTrivia());
return(initializer
.WithExpressions(
SeparatedList(
initializer.Expressions.Select(expression => expression.WithLeadingTrivia(indent2))))
.WithOpenBraceToken(initializer.OpenBraceToken.WithLeadingTrivia(indent))
.WithCloseBraceToken(initializer.CloseBraceToken.WithLeadingTrivia(indent))
.WithFormatterAnnotation());
}
public static void ComputeRefactorings(RefactoringContext context, InterpolationSyntax interpolation)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeInterpolationIntoInterpolatedString) &&
MergeInterpolationIntoInterpolatedStringRefactoring.CanRefactor(interpolation))
{
string innerText = SyntaxUtility.GetStringLiteralInnerText((LiteralExpressionSyntax)interpolation.Expression);
context.RegisterRefactoring(
$"Merge '{innerText}' into interpolated string",
cancellationToken => MergeInterpolationIntoInterpolatedStringRefactoring.RefactorAsync(context.Document, interpolation, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveInterpolation) &&
(interpolation.OpenBraceToken.Span.Contains(context.Span) ||
interpolation.CloseBraceToken.Span.Contains(context.Span)))
{
context.RegisterRefactoring("Remove interpolation",
cancellationToken =>
{
return(RemoveInterpolationRefactoring.RefactorAsync(
context.Document,
interpolation,
cancellationToken));
});
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ExpressionStatementSyntax expressionStatement)
{
if (context.SupportsSemanticModel)
{
var expression = expressionStatement.Expression as TypeSyntax;
if (expression != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel
.GetTypeInfo(expression, context.CancellationToken).Type;
if (typeSymbol?.IsErrorType() == false)
{
string name = SyntaxUtility.CreateIdentifier(typeSymbol, firstCharToLower: true);
if (!string.IsNullOrEmpty(name))
{
context.RegisterRefactoring(
$"Add identifier '{name}'",
c => RefactorAsync(context.Document, expressionStatement, name, c));
}
}
}
}
}
private async Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax member,
CancellationToken cancellationToken = default(CancellationToken))
{
if (member.IsParentKind(SyntaxKind.CompilationUnit))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
string name = SyntaxUtility.GetUniqueName("Namespace", semanticModel, member.Span.Start);
NamespaceDeclarationSyntax namespaceDeclaration = NamespaceDeclaration(
IdentifierName(Identifier(name).WithRenameAnnotation()),
default(SyntaxList <ExternAliasDirectiveSyntax>),
default(SyntaxList <UsingDirectiveSyntax>),
SingletonList(member));
SyntaxNode newRoot = root.ReplaceNode(member, namespaceDeclaration.WithFormatterAnnotation());
return(document.WithSyntaxRoot(newRoot));
}
return(document);
}
private static ExpressionSyntax GetNullableOfTValueProperty(ExpressionSyntax expression, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (expression.Kind() != SyntaxKind.SimpleMemberAccessExpression)
{
return(null);
}
var memberAccessExpression = (MemberAccessExpressionSyntax)expression;
if (!(memberAccessExpression.Name is IdentifierNameSyntax identifierName))
{
return(null);
}
if (!string.Equals(identifierName.Identifier.ValueText, "Value", StringComparison.Ordinal))
{
return(null);
}
if (!SyntaxUtility.IsPropertyOfNullableOfT(expression, "Value", semanticModel, cancellationToken))
{
return(null);
}
return(memberAccessExpression.Expression);
}
public static void ParseEnumExpression <TEnum>(
ExpressionSyntax argumentExpr,
IDictionary <AttributeParamName, object> target,
AttributeParamName key) where TEnum : Enum
{
var enumValue = SyntaxUtility.ParseEnumValue <TEnum>(argumentExpr);
target[key] = enumValue;
}
private static async Task <Document> IntroduceFieldToLockOnAsync(
Document document,
LockStatementSyntax lockStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
MemberDeclarationSyntax containingMember = lockStatement.FirstAncestorOrSelf <MemberDeclarationSyntax>();
if (containingMember != null)
{
var containingDeclaration = (MemberDeclarationSyntax)containingMember
.Ancestors()
.FirstOrDefault(f => f.IsKind(
SyntaxKind.ClassDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.StructDeclaration));
if (containingDeclaration != null)
{
SyntaxList <MemberDeclarationSyntax> members = containingDeclaration.GetMembers();
int index = members.IndexOf(containingMember);
string name = LockObjectName;
if (document.SupportsSemanticModel)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
name = SyntaxUtility.GetUniqueName(name, semanticModel, lockStatement.Expression.Span.Start);
}
LockStatementSyntax newLockStatement = lockStatement
.WithExpression(IdentifierName(name));
MemberDeclarationSyntax newContainingMember = containingMember
.ReplaceNode(lockStatement, newLockStatement);
bool isStatic = containingMember.GetModifiers().Contains(SyntaxKind.StaticKeyword);
FieldDeclarationSyntax field = CreateField(name, isStatic).WithFormatterAnnotation();
SyntaxList <MemberDeclarationSyntax> newMembers = members
.Replace(members[index], newContainingMember)
.Insert(FindField(members, index) + 1, field);
MemberDeclarationSyntax newNode = containingDeclaration.SetMembers(newMembers);
SyntaxNode newRoot = root.ReplaceNode(containingDeclaration, newNode);
return(document.WithSyntaxRoot(newRoot));
}
}
return(document);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ParameterSyntax parameter)
{
if (!context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.AddParameterNameToParameter,
RefactoringIdentifiers.RenameParameterAccordingToTypeName))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IParameterSymbol parameterSymbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken);
if (parameterSymbol?.Type == null)
{
return;
}
if (parameter.Identifier.IsMissing)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddParameterNameToParameter))
{
TextSpan span = (parameter.Type != null)
? TextSpan.FromBounds(parameter.Type.Span.End, parameter.Span.End)
: parameter.Span;
if (span.Contains(context.Span))
{
string name = SyntaxUtility.CreateIdentifier(parameterSymbol.Type, firstCharToLower: true);
if (!string.IsNullOrEmpty(name))
{
context.RegisterRefactoring(
$"Add parameter name '{name}'",
cancellationToken => AddParameterNameToParameterAsync(context.Document, parameter, name, cancellationToken));
}
}
}
}
else if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameParameterAccordingToTypeName) &&
parameter.Identifier.Span.Contains(context.Span))
{
string name = parameter.Identifier.ValueText;
string newName = SyntaxUtility.CreateIdentifier(parameterSymbol.Type, firstCharToLower: true);
if (!string.IsNullOrEmpty(newName) &&
!string.Equals(name, newName, StringComparison.Ordinal))
{
ISymbol symbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken);
context.RegisterRefactoring(
$"Rename parameter to '{newName}'",
cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken));
}
}
}
private static bool IsPropertyOfNullableOfT(
ExpressionSyntax expression,
string name,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
return(expression?.Kind() == SyntaxKind.IdentifierName &&
string.Equals(((IdentifierNameSyntax)expression).Identifier.ValueText, name, StringComparison.Ordinal) &&
SyntaxUtility.IsPropertyOfNullableOfT(expression, name, semanticModel, cancellationToken));
}
private static ExpressionSyntax AddParenthesesIfNecessary(SyntaxNode node, ExpressionSyntax expression)
{
if (!SyntaxUtility.AreParenthesesRedundantOrInvalid(node))
{
expression = expression
.WithoutTrivia()
.Parenthesize(cutCopyTrivia: true);
}
return(expression);
}
public static async Task <Document> RefactorAsync(
Document document,
PropertyDeclarationSyntax propertyDeclaration,
bool prefixIdentifierWithUnderscore = true,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
string fieldName = TextUtility.ToCamelCase(
propertyDeclaration.Identifier.ValueText,
prefixWithUnderscore: prefixIdentifierWithUnderscore);
FieldDeclarationSyntax fieldDeclaration = CreateBackingField(propertyDeclaration, fieldName)
.WithFormatterAnnotation();
PropertyDeclarationSyntax newPropertyDeclaration = ExpandPropertyAndAddBackingField(propertyDeclaration, fieldName)
.WithTriviaFrom(propertyDeclaration)
.WithFormatterAnnotation();
var parentMember = (MemberDeclarationSyntax)propertyDeclaration.Parent;
SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers();
int propertyIndex = members.IndexOf(propertyDeclaration);
if (propertyDeclaration.IsReadOnlyAutoProperty())
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(
semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken),
document.Project.Solution,
cancellationToken).ConfigureAwait(false);
ImmutableArray <IdentifierNameSyntax> identifierNames = SyntaxUtility
.FindNodes <IdentifierNameSyntax>(oldRoot, referencedSymbols)
.ToImmutableArray();
var rewriter = new IdentifierNameSyntaxRewriter(identifierNames, Identifier(fieldName));
var newParentMember = (MemberDeclarationSyntax)rewriter.Visit(parentMember);
members = newParentMember.GetMembers();
}
int indexOfLastField = members.LastIndexOf(f => f.IsKind(SyntaxKind.FieldDeclaration));
SyntaxList <MemberDeclarationSyntax> newMembers = members
.Replace(members[propertyIndex], newPropertyDeclaration)
.Insert(indexOfLastField + 1, fieldDeclaration);
SyntaxNode newRoot = oldRoot.ReplaceNode(parentMember, parentMember.SetMembers(newMembers));
return(document.WithSyntaxRoot(newRoot));
}
public static async Task <Document> RefactorAsync(
Document document,
ReturnStatementSyntax returnStatement,
ITypeSymbol typeSymbol,
ISymbol symbol,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax expression = SyntaxUtility.CreateDefaultValue(typeSymbol);
root = root.ReplaceNode(
returnStatement,
returnStatement.WithExpression(expression));
return(document.WithSyntaxRoot(root));
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, LocalDeclarationStatementSyntax localDeclaration)
{
if (context.SupportsSemanticModel)
{
TypeSyntax type = localDeclaration.Declaration?.Type;
if (type?.IsVar == false)
{
VariableDeclaratorSyntax declarator = localDeclaration.Declaration.Variables.FirstOrDefault();
if (declarator != null &&
context.Span.Start >= type.Span.Start)
{
SyntaxTriviaList triviaList = type.GetTrailingTrivia();
if (triviaList.Any())
{
SyntaxTrivia trivia = triviaList
.SkipWhile(f => f.IsKind(SyntaxKind.WhitespaceTrivia))
.FirstOrDefault();
if (trivia.IsKind(SyntaxKind.EndOfLineTrivia) &&
context.Span.End <= trivia.Span.Start)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(type, context.CancellationToken).Type;
if (typeSymbol?.IsErrorType() == false)
{
string name = SyntaxUtility.CreateIdentifier(typeSymbol, firstCharToLower: true);
if (!string.IsNullOrEmpty(name))
{
context.RegisterRefactoring(
$"Add identifier '{name}'",
c => RefactorAsync(context.Document, declarator, type, name, c));
}
}
}
}
}
}
}
}
public static bool CanRefactor(RefactoringContext context, ExpressionSyntax expression)
{
if (!SyntaxUtility.AreParenthesesRedundantOrInvalid(expression))
{
try
{
Refactor(expression, context.Root);
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
Debug.Assert(false, $"{nameof(WrapExpressionInParenthesesRefactoring)}\r\n{expression.Kind().ToString()}");
}
}
return(false);
}
private static IEnumerable <SyntaxNodeOrToken> CreateNodesAndTokens(ParameterListSyntax list)
{
SyntaxTriviaList trivia = SyntaxUtility.GetIndentTrivia(list.Parent).Add(CSharpFactory.IndentTrivia());
SeparatedSyntaxList <ParameterSyntax> .Enumerator en = list.Parameters.GetEnumerator();
if (en.MoveNext())
{
yield return(en.Current.WithLeadingTrivia(trivia));
while (en.MoveNext())
{
yield return(Token(SyntaxKind.CommaToken).WithTrailingNewLine());
yield return(en.Current.WithLeadingTrivia(trivia));
}
}
}
private static async Task RenameVariableAccordingToTypeNameAsync(
RefactoringContext context,
VariableDeclarationSyntax variableDeclaration)
{
if (variableDeclaration.Type != null &&
variableDeclaration.Parent?.IsKind(SyntaxKind.EventFieldDeclaration) == false &&
variableDeclaration.Variables.Count == 1 &&
variableDeclaration.Variables[0].Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(variableDeclaration.Variables[0], context.CancellationToken);
if (symbol != null)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type, context.CancellationToken).Type;
if (typeSymbol?.IsErrorType() == false)
{
string newName = SyntaxUtility.CreateIdentifier(
typeSymbol,
FirstCharToLower(symbol));
if (!string.IsNullOrEmpty(newName))
{
if (context.Settings.PrefixFieldIdentifierWithUnderscore &&
symbol.IsField() &&
symbol.IsPrivate() &&
!((IFieldSymbol)symbol).IsConst)
{
newName = TextUtility.ToCamelCaseWithUnderscore(newName);
}
if (!string.Equals(variableDeclaration.Variables[0].Identifier.ValueText, newName, StringComparison.Ordinal))
{
context.RegisterRefactoring(
$"Rename {GetName(symbol)} to '{newName}'",
cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken));
}
}
}
}
}
}
private static async Task <Document> FormatOnMultipleLinesAsync(
Document document,
BinaryExpressionSyntax condition,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SyntaxTriviaList triviaList = SyntaxFactory.TriviaList(CSharpFactory.NewLineTrivia())
.AddRange(SyntaxUtility.GetIndentTrivia(condition))
.Add(CSharpFactory.IndentTrivia());
var rewriter = new BinaryExpressioneSyntaxRewriter(triviaList);
var newCondition = (ExpressionSyntax)rewriter.Visit(condition);
root = root.ReplaceNode(condition, newCondition);
return(document.WithSyntaxRoot(root));
}
private static bool IsPropertyOfNullableOfT(ExpressionSyntax expression, string name, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (expression?.Kind() == SyntaxKind.SimpleMemberAccessExpression)
{
var memberAccessExpression = (MemberAccessExpressionSyntax)expression;
SimpleNameSyntax simpleName = memberAccessExpression.Name;
if (simpleName?.Kind() == SyntaxKind.IdentifierName)
{
var identifierName = (IdentifierNameSyntax)simpleName;
return(string.Equals(identifierName.Identifier.ValueText, name, StringComparison.Ordinal) &&
SyntaxUtility.IsPropertyOfNullableOfT(expression, name, semanticModel, cancellationToken));
}
}
return(false);
}
private static async Task <ExpressionSyntax> ReplaceParameterExpressionWithArgumentExpressionAsync(
ParameterInfo[] parameterInfos,
InvocationExpressionSyntax invocation,
ExpressionSyntax expression,
Solution solution,
CancellationToken cancellationToken)
{
ExpressionSyntax newExpression = await ReplaceParameterExpressionWithArgumentExpressionAsync(parameterInfos, expression, solution, cancellationToken).ConfigureAwait(false);
if (!SyntaxUtility.AreParenthesesRedundantOrInvalid(invocation))
{
newExpression = newExpression
.WithoutTrivia()
.Parenthesize();
}
return(newExpression
.WithTriviaFrom(invocation)
.WithFormatterAnnotation());
}
private static VariableDeclaratorSyntax GetNewDeclarator(
VariableDeclaratorSyntax declarator,
TypeSyntax type,
ITypeSymbol typeSymbol)
{
ExpressionSyntax value = SyntaxUtility.CreateDefaultValue(typeSymbol, type);
EqualsValueClauseSyntax @default = EqualsValueClause(value);
if (declarator.Initializer == null || declarator.Initializer.IsMissing)
{
return(declarator
.WithIdentifier(declarator.Identifier.WithoutTrailingTrivia())
.WithInitializer(@default.WithTrailingTrivia(declarator.Identifier.TrailingTrivia)));
}
else
{
return(declarator
.WithInitializer(@default.WithTriviaFrom(declarator.Initializer.EqualsToken)));
}
}
private static async Task <Document> FormatExpressionChainOnMultipleLinesAsync(
Document document,
ImmutableArray <MemberAccessExpressionSyntax> expressions,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
MemberAccessExpressionSyntax expression = expressions[0];
SyntaxTriviaList triviaList = SyntaxUtility.GetIndentTrivia(expression).Add(CSharpFactory.IndentTrivia());
triviaList = triviaList.Insert(0, CSharpFactory.NewLineTrivia());
var rewriter = new ExpressionChainSyntaxRewriter(expressions, triviaList);
SyntaxNode newNode = rewriter.Visit(expression)
.WithFormatterAnnotation();
SyntaxNode newRoot = oldRoot.ReplaceNode(expression, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public static async Task <Document> RefactorAsync(
Document document,
InterpolationSyntax interpolation,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var interpolatedString = (InterpolatedStringExpressionSyntax)interpolation.Parent;
string s = interpolatedString.ToString();
s = s.Substring(0, interpolation.Span.Start - interpolatedString.Span.Start)
+ SyntaxUtility.GetStringLiteralInnerText((LiteralExpressionSyntax)interpolation.Expression)
+ s.Substring(interpolation.Span.End - interpolatedString.Span.Start);
var newInterpolatedString = (InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression(s)
.WithTriviaFrom(interpolatedString);
SyntaxNode newRoot = root.ReplaceNode(interpolatedString, newInterpolatedString);
return(document.WithSyntaxRoot(newRoot));
}
private static ParameterSyntax GetNewParameter(
ParameterSyntax parameter,
ITypeSymbol typeSymbol)
{
ExpressionSyntax value = SyntaxUtility.CreateDefaultValue(
typeSymbol,
parameter.Type.WithoutTrivia());
EqualsValueClauseSyntax @default = EqualsValueClause(value);
if (parameter.Default == null || parameter.IsMissing)
{
return(parameter
.WithIdentifier(parameter.Identifier.WithoutTrailingTrivia())
.WithDefault(@default.WithTrailingTrivia(parameter.Identifier.TrailingTrivia)));
}
else
{
return(parameter
.WithDefault(@default.WithTriviaFrom(parameter.Default.EqualsToken)));
}
}
private static async Task RenameMethodAccoringToTypeNameAsync(
RefactoringContext context,
MethodDeclarationSyntax methodDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameMethodAccordingToTypeName) &&
context.SupportsSemanticModel &&
methodDeclaration.ReturnType?.IsVoid() == false &&
methodDeclaration.Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = GetType(methodDeclaration.ReturnType, semanticModel, context.CancellationToken);
if (typeSymbol != null)
{
string newName = SyntaxUtility.CreateIdentifier(typeSymbol);
if (!string.IsNullOrEmpty(newName))
{
newName = "Get" + newName;
if (methodSymbol.IsAsync)
{
newName += "Async";
}
if (!string.Equals(newName, methodDeclaration.Identifier.ValueText, StringComparison.Ordinal))
{
context.RegisterRefactoring(
$"Rename method to '{newName}'",
cancellationToken => SymbolRenamer.RenameAsync(context.Document, methodSymbol, newName, cancellationToken));
}
}
}
}
}
private static IEnumerable <SyntaxNodeOrToken> CreateMultilineNodesAndTokens(AttributeArgumentListSyntax argumentList)
{
SyntaxTriviaList trivia = SyntaxUtility.GetIndentTrivia(argumentList.Parent).Add(CSharpFactory.IndentTrivia());
SeparatedSyntaxList <AttributeArgumentSyntax> .Enumerator en = argumentList.Arguments.GetEnumerator();
if (en.MoveNext())
{
yield return(en.Current
.TrimTrailingTrivia()
.WithLeadingTrivia(trivia));
while (en.MoveNext())
{
yield return(Token(SyntaxKind.CommaToken)
.WithTrailingNewLine());
yield return(en.Current
.TrimTrailingTrivia()
.WithLeadingTrivia(trivia));
}
}
}
