public override void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Value?.Accept(this);
base.VisitInterpolationAlignmentClause(node);
PostVisit(node);
}
public new void AddChildren()
{
base.AddChildren();
Kind = Node.Kind();
_openBraceToken = ((InterpolationSyntax)Node).OpenBraceToken;
_openBraceTokenIsChanged = false;
_expression = ((InterpolationSyntax)Node).Expression;
_expressionIsChanged = false;
_alignmentClause = ((InterpolationSyntax)Node).AlignmentClause;
_alignmentClauseIsChanged = false;
_formatClause = ((InterpolationSyntax)Node).FormatClause;
_formatClauseIsChanged = false;
_closeBraceToken = ((InterpolationSyntax)Node).CloseBraceToken;
_closeBraceTokenIsChanged = false;
}
private static InterpolationAlignmentClauseSyntax TryCreateAlignmentExpression(int width, bool leftJustify)
{
if (width == 0)
{
return(null);
}
LiteralExpressionSyntax widthExpression = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(width));
ExpressionSyntax alignmentValueExpression = leftJustify ?
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, widthExpression) as ExpressionSyntax :
widthExpression as ExpressionSyntax;
InterpolationAlignmentClauseSyntax alignmentClause = SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Token(SyntaxKind.CommaToken), alignmentValueExpression);
return(alignmentClause);
}
private InterpolationSyntax ParseInterpolation(string text, Lexer.Interpolation interpolation, bool isVerbatim)
{
SyntaxToken openBraceToken;
ExpressionSyntax expression;
InterpolationAlignmentClauseSyntax alignment = null;
InterpolationFormatClauseSyntax format = null;
var closeBraceToken = interpolation.CloseBraceMissing
? SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken)
: SyntaxFactory.Token(SyntaxKind.CloseBraceToken);
var parsedText = Substring(text, interpolation.OpenBracePosition, interpolation.HasColon ? interpolation.ColonPosition - 1 : interpolation.CloseBracePosition - 1);
using (var tempLexer = new Lexer(Text.SourceText.From(parsedText), this.Options, allowPreprocessorDirectives: false, interpolationFollowedByColon: interpolation.HasColon))
{
// TODO: some of the trivia in the interpolation maybe should be trailing trivia of the openBraceToken
using (var tempParser = new LanguageParser(tempLexer, null, null))
{
SyntaxToken commaToken = null;
ExpressionSyntax alignmentExpression = null;
tempParser.ParseInterpolationStart(out openBraceToken, out expression, out commaToken, out alignmentExpression);
if (alignmentExpression != null)
{
alignment = SyntaxFactory.InterpolationAlignmentClause(commaToken, alignmentExpression);
}
var extraTrivia = tempParser.CurrentToken.GetLeadingTrivia();
if (interpolation.HasColon)
{
var colonToken = SyntaxFactory.Token(SyntaxKind.ColonToken).TokenWithLeadingTrivia(extraTrivia);
var formatText = Substring(text, interpolation.ColonPosition + 1, interpolation.FormatEndPosition);
var formatString = MakeStringToken(formatText, formatText, isVerbatim, SyntaxKind.InterpolatedStringTextToken);
format = SyntaxFactory.InterpolationFormatClause(colonToken, formatString);
}
else
{
// Move the leading trivia from the insertion's EOF token to the following token.
closeBraceToken = closeBraceToken.TokenWithLeadingTrivia(extraTrivia);
}
}
}
var result = SyntaxFactory.Interpolation(openBraceToken, expression, alignment, format, closeBraceToken);
Debug.Assert(Substring(text, interpolation.OpenBracePosition, interpolation.LastPosition) == result.ToFullString()); // yield from text equals yield from node
return(result);
}
public static InterpolatedStringContentConversion Create(InterpolatedStringContentSyntax content, bool isVerbatim)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
SyntaxKind kind = content.Kind();
switch (kind)
{
case SyntaxKind.Interpolation:
{
var interpolation = (InterpolationSyntax)content;
InterpolationAlignmentClauseSyntax alignmentClause = interpolation.AlignmentClause;
InterpolationFormatClauseSyntax formatClause = interpolation.FormatClause;
if (alignmentClause != null ||
formatClause != null)
{
var sb = new StringBuilder();
sb.Append("\"{0");
if (alignmentClause != null)
{
sb.Append(',');
sb.Append(alignmentClause.Value.ToString());
}
if (formatClause != null)
{
sb.Append(':');
sb.Append(formatClause.FormatStringToken.Text);
}
sb.Append("}\"");
return(new InterpolatedStringContentConversion(kind, "AppendFormat", SeparatedList(new ArgumentSyntax[] { Argument(ParseExpression(sb.ToString())), Argument(interpolation.Expression) })));
}
else
{
return(new InterpolatedStringContentConversion(kind, "Append", SingletonSeparatedList(Argument(interpolation.Expression))));
}
}
case SyntaxKind.InterpolatedStringText:
{
var interpolatedStringText = (InterpolatedStringTextSyntax)content;
string text = interpolatedStringText.TextToken.Text;
text = (isVerbatim)
? "@\"" + text + "\""
: "\"" + text + "\"";
ExpressionSyntax stringLiteral = ParseExpression(text);
return(new InterpolatedStringContentConversion(kind, "Append", SingletonSeparatedList(Argument(stringLiteral))));
}
default:
{
throw new ArgumentException("", nameof(content));
}
}
}
private static Task <Document> RefactorAsync(
Document document,
InterpolatedStringExpressionSyntax interpolatedString,
CancellationToken cancellationToken)
{
StringBuilder sb = StringBuilderCache.GetInstance();
var b = new SyntaxNodeTextBuilder(interpolatedString, sb);
var arguments = new List <ArgumentSyntax>()
{
null
};
if (interpolatedString.IsVerbatim())
{
b.Append("@");
}
b.Append("\"");
int index = 0;
foreach (InterpolatedStringContentSyntax content in interpolatedString.Contents)
{
switch (content.Kind())
{
case SyntaxKind.Interpolation:
{
var interpolation = (InterpolationSyntax)content;
b.Append("{");
b.Append(index.ToString(CultureInfo.InvariantCulture));
index++;
InterpolationAlignmentClauseSyntax alignmentClause = interpolation.AlignmentClause;
if (alignmentClause != null)
{
b.Append(",");
b.AppendSpan(alignmentClause.Value);
}
InterpolationFormatClauseSyntax formatClause = interpolation.FormatClause;
if (formatClause != null)
{
b.Append(":");
b.AppendSpan(formatClause.FormatStringToken);
}
b.Append("}");
arguments.Add(Argument(interpolation.Expression));
break;
}
case SyntaxKind.InterpolatedStringText:
{
b.AppendSpan(content);
break;
}
}
}
b.Append("\"");
arguments[0] = Argument(ParseExpression(StringBuilderCache.GetStringAndFree(sb)));
InvocationExpressionSyntax invocation = SimpleMemberInvocationExpression(
CSharpTypeFactory.StringType(),
IdentifierName("Format"),
ArgumentList(SeparatedList(arguments)));
invocation = invocation.WithTriviaFrom(interpolatedString).WithFormatterAnnotation();
return(document.ReplaceNodeAsync(interpolatedString, invocation, cancellationToken));
}
//public override void VisitInterpolation(InterpolationSyntax node)
//{
// base.VisitInterpolation(node);
//}
public override void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
//base.VisitInterpolationAlignmentClause(node);
}
public override void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
node.Value?.Accept(this);
base.VisitInterpolationAlignmentClause(node);
}
public override void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public override Expression VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
throw Unexpected(node, nameof(VisitInterpolatedStringExpression));
}
public override void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
Log(node, "Unsupported Syntax !");
}
public static bool TryCreate(InterpolatedStringContentSyntax content, bool isVerbatim, out InterpolatedStringContentConversion conversion)
{
switch (content?.Kind())
{
case SyntaxKind.Interpolation:
{
var interpolation = (InterpolationSyntax)content;
InterpolationAlignmentClauseSyntax alignmentClause = interpolation.AlignmentClause;
InterpolationFormatClauseSyntax formatClause = interpolation.FormatClause;
if (alignmentClause != null ||
formatClause != null)
{
var sb = new StringBuilder();
sb.Append("\"{0");
if (alignmentClause != null)
{
sb.Append(',');
sb.Append(alignmentClause.Value.ToString());
}
if (formatClause != null)
{
sb.Append(':');
sb.Append(formatClause.FormatStringToken.Text);
}
sb.Append("}\"");
conversion = new InterpolatedStringContentConversion("AppendFormat", SeparatedList(new ArgumentSyntax[] { Argument(ParseExpression(sb.ToString())), Argument(interpolation.Expression) }));
return(true);
}
else
{
conversion = new InterpolatedStringContentConversion("Append", SingletonSeparatedList(Argument(interpolation.Expression)));
return(true);
}
}
case SyntaxKind.InterpolatedStringText:
{
var interpolatedStringText = (InterpolatedStringTextSyntax)content;
string text = interpolatedStringText.TextToken.Text;
text = (isVerbatim)
? "@\"" + text + "\""
: "\"" + text + "\"";
ExpressionSyntax stringLiteral = ParseExpression(text);
conversion = new InterpolatedStringContentConversion("Append", SingletonSeparatedList(Argument(stringLiteral)));
return(true);
}
}
conversion = default(InterpolatedStringContentConversion);
return(false);
}
public override Ust VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
return(base.VisitInterpolationAlignmentClause(node));
}
Refactor(InterpolatedStringContentSyntax content, bool isVerbatim)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
SyntaxKind kind = content.Kind();
switch (kind)
{
case SyntaxKind.Interpolation:
{
var interpolation = (InterpolationSyntax)content;
InterpolationAlignmentClauseSyntax alignmentClause = interpolation.AlignmentClause;
InterpolationFormatClauseSyntax formatClause = interpolation.FormatClause;
if (alignmentClause != null ||
formatClause != null)
{
StringBuilder sb = StringBuilderCache.GetInstance();
sb.Append("\"{0");
if (alignmentClause != null)
{
sb.Append(',');
sb.Append(alignmentClause.Value.ToString());
}
if (formatClause != null)
{
sb.Append(':');
sb.Append(formatClause.FormatStringToken.Text);
}
sb.Append("}\"");
ExpressionSyntax expression = ParseExpression(StringBuilderCache.GetStringAndFree(sb));
return(kind, "AppendFormat", ImmutableArray.Create(Argument(expression), Argument(interpolation.Expression)));
}
else
{
return(kind, "Append", ImmutableArray.Create(Argument(interpolation.Expression)));
}
}
case SyntaxKind.InterpolatedStringText:
{
var interpolatedStringText = (InterpolatedStringTextSyntax)content;
string text = interpolatedStringText.TextToken.Text;
text = StringUtility.ReplaceDoubleBracesWithSingleBrace(text);
text = (isVerbatim)
? "@\"" + text + "\""
: "\"" + text + "\"";
ExpressionSyntax stringLiteral = ParseExpression(text);
return(kind, "Append", ImmutableArray.Create(Argument(stringLiteral)));
}
default:
{
throw new ArgumentException("", nameof(content));
}
}
}
// // Summary: // Called when the visitor visits a InterpolationAlignmentClauseSyntax node. public virtual void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node);
public override SyntaxNode VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
node = (InterpolationAlignmentClauseSyntax)base.VisitInterpolationAlignmentClause(node);
Classes.Add(node);
return(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitInterpolationAlignmentClause(node);
}
public override Evaluation VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
node.Value?.Accept <Evaluation>(this);
return(base.VisitInterpolationAlignmentClause(node));
}
public TameInterpolationAlignmentClauseSyntax(InterpolationAlignmentClauseSyntax node)
{
Node = node;
AddChildren();
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitInterpolationAlignmentClause(InterpolationAlignmentClauseSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitInterpolationAlignmentClause(node);
}
