private static SyntaxNode CreateNewLiteral(LiteralExpressionSyntax literal, SyntaxNode root)
{
SyntaxNode newRoot;
if (literal.Token.ValueText != literal.Token.Text)
{
var newTokenText = literal.Token.ValueText;
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
newRoot = root.ReplaceNode(literal, newLiteral);
}
else
{
var value = (dynamic)literal.Token.Value;
if (literal.Parent != null && literal.Parent.IsKind(SyntaxKind.UnaryMinusExpression))
{
var newTokenText = (string)("0x" + (value * -1).ToString("X"));
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText))
.WithLeadingTrivia(literal.Parent.GetLeadingTrivia())
.WithTrailingTrivia(literal.Parent.GetTrailingTrivia());
newRoot = root.ReplaceNode(literal.Parent, newLiteral);
}
else
{
var newTokenText = (string)("0x" + value.ToString("X"));
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
newRoot = root.ReplaceNode(literal, newLiteral);
}
}
return newRoot;
}
private static SyntaxNode CreateNewLiteral(LiteralExpressionSyntax literal, SyntaxNode root)
{
SyntaxNode newRoot;
if (literal.Token.ValueText != literal.Token.Text)
{
var newTokenText = literal.Token.ValueText;
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
newRoot = root.ReplaceNode(literal, newLiteral);
}
else
{
var value = (dynamic)literal.Token.Value;
if (literal.Parent != null && literal.Parent.IsKind(SyntaxKind.UnaryMinusExpression))
{
var newTokenText = (string)("0x" + (value * -1).ToString("X"));
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText))
.WithLeadingTrivia(literal.Parent.GetLeadingTrivia())
.WithTrailingTrivia(literal.Parent.GetTrailingTrivia());
newRoot = root.ReplaceNode(literal.Parent, newLiteral);
}
else
{
var newTokenText = (string)("0x" + value.ToString("X"));
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
newRoot = root.ReplaceNode(literal, newLiteral);
}
}
return(newRoot);
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.Kind().Equals(SyntaxKind.NumericLiteralExpression))
{
return(base.VisitLiteralExpression(node.ReplaceNode(node, node.WithToken(SyntaxFactory.ParseToken(node.Token.ValueText)))));
}
return(base.VisitLiteralExpression(node));
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.Token.IsKind(SyntaxKind.StringLiteralToken))
{
return(node.WithToken(SyntaxFactory.Literal(node.Token.ValueText.Replace("\r\n", "\r\n<br />"))));
}
return(node);
}
public static LiteralExpressionSyntax WithToken(
this LiteralExpressionSyntax syntax,
string text,
string valueText)
{
SyntaxToken token = syntax.Token;
return(syntax.WithToken(
SyntaxFactory.Token(token.LeadingTrivia, token.Kind(), text, valueText, token.TrailingTrivia)));
}
public override SyntaxNode?VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression))
{
return(base.VisitLiteralExpression(
node.WithToken(
SyntaxFactory.Literal(
node.Token.LeadingTrivia, node.Token.ValueText, node.Token.ValueText, node.Token.TrailingTrivia))));
}
return(base.VisitLiteralExpression(node));
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.StringLiteralExpression) &&
node.Parent is ArgumentSyntax argument &&
argument.Parent is ArgumentListSyntax argumentList &&
argumentList.Parent is InvocationExpressionSyntax invocation &&
invocation.TryGetMethodName(out var method) &&
method == "GetString")
{
return(node.WithToken(SyntaxFactory.Literal(this.newKey)));
}
return(base.VisitLiteralExpression(node));
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.Kind().Equals(SyntaxKind.NumericLiteralExpression))
{
if (int.TryParse(node.Token.ValueText, out int result))
{
LiteralExpressionSyntax newExp;
if (result < 10)
{
newExp = node.WithToken(SyntaxFactory.ParseToken(NumberOperations.DecToBin(node.Token.ValueText)));
}
else
{
newExp = node.WithToken(SyntaxFactory.ParseToken(NumberOperations.DecToHex(node.Token.ValueText)));
}
var newNode = node.ReplaceNode(node, newExp);
return(base.VisitLiteralExpression(newNode));
}
}
return(base.VisitLiteralExpression(node));
}
private static SyntaxNode RewriteCharacterLiteralExpression(LiteralExpressionSyntax node)
{
Debug.Assert(node.Kind() == SyntaxKind.CharacterLiteralExpression);
if (HasNonAsciiCharacters(node.Token.Text))
{
string convertedText = EscapeNonAsciiCharacters(node.Token.Text);
SyntaxToken t = SyntaxFactory.Literal(node.Token.LeadingTrivia, convertedText, node.Token.ValueText, node.Token.TrailingTrivia);
node = node.WithToken(t);
}
return node;
}
private static SyntaxNode RewriteCharacterLiteralExpression(LiteralExpressionSyntax node)
{
Debug.Assert(node.Kind() == SyntaxKind.CharacterLiteralExpression);
if (HasNonAsciiCharacters(node.Token.Text))
{
string convertedText = EscapeNonAsciiCharacters(node.Token.Text);
SyntaxToken t = SyntaxFactory.Literal(node.Token.LeadingTrivia, convertedText, node.Token.ValueText, node.Token.TrailingTrivia);
node = node.WithToken(t);
}
return(node);
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression) &&
node.Token.IsKind(SyntaxKind.NumericLiteralToken) &&
node.Token.Value is double value &&
node.Token.Text.Contains("e"))
{
return(base.VisitLiteralExpression(
node.WithToken(
SyntaxFactory.Literal(
node.Token.Text.Replace("e", "E"),
value))));
}
return(base.VisitLiteralExpression(node));
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
var newNode = node;
if (node.IsKind(SyntaxKind.StringLiteralExpression) ||
node.IsKind(SyntaxKind.CharacterLiteralExpression) ||
node.IsKind(SyntaxKind.NumericLiteralExpression))
{
// even if the node is a Numerical Literal token, we replace it as a string literal
if (node.Token.ValueText != "0" && node.Token.ValueText != "1")
{
newNode = node.WithToken(SyntaxFactory.Token(node.Token.LeadingTrivia, SyntaxKind.StringLiteralToken, "LITERAL",
"LITERAL", node.Token.TrailingTrivia));
}
}
return(base.VisitLiteralExpression(newNode));
}
private static SyntaxNode RewriteStringLiteralExpression(LiteralExpressionSyntax node)
{
Debug.Assert(node.Kind() == SyntaxKind.StringLiteralExpression);
if (node.Token.IsVerbatimStringLiteral())
{
// We do not correctly rewrite verbatim string literals yet. Once Issue 39 is
// fixed we can remove this early out.
return node;
}
if (HasNonAsciiCharacters(node.Token.Text))
{
string convertedText = EscapeNonAsciiCharacters(node.Token.Text);
SyntaxToken t = SyntaxFactory.Literal(node.Token.LeadingTrivia, convertedText, node.Token.ValueText, node.Token.TrailingTrivia);
node = node.WithToken(t);
}
return node;
}
private static SyntaxNode RewriteStringLiteralExpression(LiteralExpressionSyntax node)
{
Debug.Assert(node.Kind() == SyntaxKind.StringLiteralExpression);
if (node.Token.IsVerbatimStringLiteral())
{
// We do not correctly rewrite verbatim string literals yet. Once Issue 39 is
// fixed we can remove this early out.
return(node);
}
if (HasNonAsciiCharacters(node.Token.Text))
{
string convertedText = EscapeNonAsciiCharacters(node.Token.Text);
SyntaxToken t = SyntaxFactory.Literal(node.Token.LeadingTrivia, convertedText, node.Token.ValueText, node.Token.TrailingTrivia);
node = node.WithToken(t);
}
return(node);
}
internal static LiteralExpressionSyntax WithLiteralSuffix(this LiteralExpressionSyntax literalExpression, SyntaxKind syntaxKindKeyword)
{
string textWithoutSuffix = literalExpression.StripLiteralSuffix();
string suffix;
switch (syntaxKindKeyword)
{
case SyntaxKind.UIntKeyword:
suffix = "U";
break;
case SyntaxKind.ULongKeyword:
suffix = "UL";
break;
case SyntaxKind.LongKeyword:
suffix = "L";
break;
case SyntaxKind.FloatKeyword:
suffix = "F";
break;
case SyntaxKind.DoubleKeyword:
suffix = "D";
break;
case SyntaxKind.DecimalKeyword:
suffix = "M";
break;
default:
suffix = string.Empty;
break;
}
return(literalExpression.WithToken(SyntaxFactory.ParseToken(textWithoutSuffix + suffix).WithTriviaFrom(literalExpression.Token)));
}
public (SyntaxNode, EnvironmentVariable[]) Interpolate()
{
var captured = new HashSet <EnvironmentVariable>();
var literal = node.Token.ValueText;
var inlined = VariablePattern.Replace(literal, match =>
{
var name = match.Groups["variable"].Value;
if (name == NakeScriptDirectoryVariable)
{
return(Path.GetDirectoryName(filePath));
}
var value = Environment.GetEnvironmentVariable(name) ?? "";
captured.Add(new EnvironmentVariable(name, value));
return(value);
});
var interpolated = node.WithToken(SyntaxFactory.Literal(Unescape(inlined)));
return(interpolated, captured.ToArray());
}