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 <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));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
InterpolationSyntax interpolation = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <InterpolationSyntax>();
Debug.Assert(interpolation != null, $"{nameof(interpolation)} is null");
if (interpolation == null)
{
return;
}
string innerText = SyntaxUtility.GetStringLiteralInnerText((LiteralExpressionSyntax)interpolation.Expression);
CodeAction codeAction = CodeAction.Create(
$"Merge '{innerText}' into interpolated string",
cancellationToken => MergeInterpolationIntoInterpolatedStringRefactoring.RefactorAsync(context.Document, interpolation, cancellationToken),
DiagnosticIdentifiers.MergeInterpolationIntoInterpolatedString + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, context.Diagnostics);
}
public static void ComputeRefactorings(RefactoringContext context, LiteralExpressionSyntax literalExpression)
{
if (!literalExpression.Span.Contains(context.Span))
{
return;
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.InsertStringInterpolation) &&
context.SupportsCSharp6 &&
context.Span.End < literalExpression.Span.End)
{
int startIndex = GetStartIndex(context, literalExpression);
if (startIndex != -1)
{
context.RegisterRefactoring(
"Insert interpolation",
cancellationToken =>
{
return(ReplaceStringLiteralRefactoring.ReplaceWithInterpolatedStringAsync(
context.Document,
literalExpression,
startIndex,
context.Span.Length,
cancellationToken));
});
}
}
if (context.Span.IsBetweenSpans(literalExpression))
{
string text = SyntaxUtility.GetStringLiteralInnerText(literalExpression);
if (literalExpression.IsVerbatimStringLiteral())
{
if (text.Contains("\"\""))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceVerbatimStringLiteralWithRegularStringLiteral))
{
context.RegisterRefactoring(
"Replace verbatim string literal with regular string literal",
cancellationToken =>
{
return(ReplaceStringLiteralRefactoring.ReplaceWithRegularStringLiteralAsync(
context.Document,
literalExpression,
cancellationToken));
});
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceVerbatimStringLiteralWithRegularStringLiterals) &&
text.Contains("\n"))
{
context.RegisterRefactoring(
"Replace verbatim string literal with regular string literals",
cancellationToken =>
{
return(ReplaceStringLiteralRefactoring.ReplaceWithRegularStringLiteralsAsync(
context.Document,
literalExpression,
cancellationToken));
});
}
}
}
else if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceRegularStringLiteralWithVerbatimStringLiteral) &&
text.Contains(@"\"))
{
context.RegisterRefactoring(
"Replace regular string literal with verbatim string literal",
cancellationToken =>
{
return(ReplaceStringLiteralRefactoring.ReplaceWithVerbatimStringLiteralAsync(
context.Document,
literalExpression,
cancellationToken));
});
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceEmptyStringLiteralWithStringEmpty) &&
ReplaceStringLiteralRefactoring.CanReplaceWithStringEmpty(literalExpression))
{
context.RegisterRefactoring(
"Replace \"\" with 'string.Empty'",
cancellationToken =>
{
return(ReplaceStringLiteralRefactoring.ReplaceWithStringEmptyAsync(
context.Document,
literalExpression,
cancellationToken));
});
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceStringLiteralWithCharacterLiteral) &&
ReplaceStringLiteralRefactoring.CanReplaceWithCharacterLiteral(literalExpression))
{
context.RegisterRefactoring(
"Replace string literal with character literal",
cancellationToken =>
{
return(ReplaceStringLiteralRefactoring.ReplaceWithCharacterLiteralAsync(
context.Document,
literalExpression,
cancellationToken));
});
}
}
