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()); }