private static bool IsNegation(LiteralExpressionSyntax literal, LiteralExpressionSyntax literal2) { if (literal.IsKind(SyntaxKind.TrueLiteralExpression)) { return(literal2.IsKind(SyntaxKind.FalseLiteralExpression)); } else { return(literal2.IsKind(SyntaxKind.TrueLiteralExpression)); } }
private static bool IsOppositeBooleanLiteral(LiteralExpressionSyntax literal1, LiteralExpressionSyntax literal2) { if (literal1.IsKind(SyntaxKind.TrueLiteralExpression)) { return(literal2.IsKind(SyntaxKind.FalseLiteralExpression)); } else { return(literal2.IsKind(SyntaxKind.TrueLiteralExpression)); } }
public static bool TryParse(LiteralExpressionSyntax literal, out UrlTemplate template) { if (literal.IsKind(SyntaxKind.StringLiteralExpression)) { var text = literal.Token.ValueText; var builder = ImmutableArray.CreateBuilder <Component>(text.Count(x => x == '/') + 1); var start = 0; while (true) { var end = text.IndexOf('/', start); if (end < 0) { builder.Add(new Component(literal, start, text.Length)); break; } builder.Add(new Component(literal, start, end)); start = end + 1; } template = new UrlTemplate(literal, builder.MoveToImmutable()); return(true); } template = default(UrlTemplate); return(false); }
static bool TryGetDiagnostic(SyntaxNodeAnalysisContext nodeContext, out Diagnostic diagnostic) { diagnostic = default(Diagnostic); var node = nodeContext.Node as AssignmentExpressionSyntax; if (node.IsKind(SyntaxKind.OrAssignmentExpression)) { LiteralExpressionSyntax right = node.Right as LiteralExpressionSyntax; //if right is true if ((right != null) && right.IsKind(SyntaxKind.TrueLiteralExpression)) { diagnostic = Diagnostic.Create( descriptor, node.GetLocation() ); return(true); } } else if (node.IsKind(SyntaxKind.AndAssignmentExpression)) { LiteralExpressionSyntax right = node.Right as LiteralExpressionSyntax; //if right is false if ((right != null) && right.IsKind(SyntaxKind.FalseLiteralExpression)) { diagnostic = Diagnostic.Create( descriptor, node.GetLocation() ); return(true); } } return(false); }
internal static void Run(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalExpression) { if (literalExpression == null) { return; } if (literalExpression.IsKind(SyntaxKind.StringLiteralExpression) && literalExpression.Token.IsKind(SyntaxKind.StringLiteralToken)) { var sql = literalExpression.Token.ValueText; if (string.IsNullOrWhiteSpace(sql)) { return; } List <string> errors = SqlParser.Parse(sql); if (errors.Count == 0) { return; } string errorText = String.Join("\r\n", errors); var diagnostic = Diagnostic.Create(Rule, literalExpression.GetLocation(), errorText); context.ReportDiagnostic(diagnostic); } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.NullLiteralExpression)) { _hasPossibleNullValue = true; } }
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)); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (!node.IsKind(SyntaxKind.NumericLiteralExpression)) { throw new NotSupportedException(); } Result = new ConstantExpressionBuilder(node.Token.Value.GetType(), node.Token.Text); }
static bool IsNull(ExpressionSyntax candidate) { return(candidate switch { LiteralExpressionSyntax literal => literal.IsKind(SyntaxKind.NullLiteralExpression), CastExpressionSyntax cast => IsNull(cast.Expression), BinaryExpressionSyntax binary when binary.IsKind(SyntaxKind.AsExpression) => IsNull(binary.Left), _ => false, });
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.StringLiteralExpression)) { // StringLiteralToken stringLiteralToken = node.Token; // Console.WriteLine(node.Token.Value); _strings.Add((string)node.Token.Value); } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.NumericLiteralExpression)) { this.literals.Add(node); } base.VisitLiteralExpression(node); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.StringLiteralExpression) && node.ToString().IndexOf('\n') >= 0) { node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation); } return base.VisitLiteralExpression(node); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.StringLiteralExpression) && node.ToString().IndexOf('\n') >= 0) { node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation); } return(base.VisitLiteralExpression(node)); }
public static bool IsZeroNumericLiteral(this LiteralExpressionSyntax literalExpression) { if (literalExpression == null) { throw new ArgumentNullException(nameof(literalExpression)); } return(literalExpression.IsKind(SyntaxKind.NumericLiteralExpression) && string.Equals(literalExpression.Token.ValueText, "0", StringComparison.Ordinal)); }
public static bool IsVerbatimStringLiteral(this LiteralExpressionSyntax literalExpression) { if (literalExpression == null) { throw new ArgumentNullException(nameof(literalExpression)); } return(literalExpression.IsKind(SyntaxKind.StringLiteralExpression) && literalExpression.Token.Text.StartsWith("@", StringComparison.Ordinal)); }
public static Task <Document> RefactorAsync( Document document, LiteralExpressionSyntax literalExpression, CancellationToken cancellationToken = default) { LiteralExpressionSyntax newNode = BooleanLiteralExpression(!literalExpression.IsKind(SyntaxKind.TrueLiteralExpression)) .WithTriviaFrom(literalExpression); return(document.ReplaceNodeAsync(literalExpression, newNode, cancellationToken)); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { // This has to be a top-level function in order to be a valid null-value if (FunctionDepth <= 1 && node.IsKind(SyntaxKind.NullLiteralExpression)) { PossibleNullValues.Add(node); return; } base.VisitLiteralExpression(node); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.NullLiteralExpression)) { TypeExpressionLocation = node.GetLocation(); } else { base.VisitLiteralExpression(node); } }
private static LiteralExpressionSyntax GetNewNode(LiteralExpressionSyntax literalExpression) { if (literalExpression.IsKind(SyntaxKind.TrueLiteralExpression)) { return(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)); } else { return(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)); } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.NumericLiteralExpression)) { double result; if (double.TryParse(node.Token.ValueText, out result)) { Value = (isValuePositive ? 1 : -1) * result; } } }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.NullLiteralExpression)) { if (ShouldApply(node)) { return(Null); } } return(base.VisitLiteralExpression(node)); }
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 string Generate(LiteralExpressionSyntax literal, SemanticModel semanticModel) { if (literal.IsKind(SyntaxKind.NullLiteralExpression)) { return("null"); } if (literal.IsKind(SyntaxKind.TrueLiteralExpression)) { return("true"); } if (literal.IsKind(SyntaxKind.FalseLiteralExpression)) { return("false"); } if (literal.IsKind(SyntaxKind.NumericLiteralExpression)) { return(literal.ToString()); } if (literal.IsKind(SyntaxKind.StringLiteralExpression)) { return(literal.ToString()); } if (literal.IsKind(SyntaxKind.CharacterLiteralExpression)) { return(literal.ToString()); } throw new NotImplementedException(); }
public static async Task <Document> RefactorAsync( Document document, LiteralExpressionSyntax literalExpression, CancellationToken cancellationToken = default(CancellationToken)) { LiteralExpressionSyntax newNode = (literalExpression.IsKind(SyntaxKind.TrueLiteralExpression)) ? FalseLiteralExpression() : TrueLiteralExpression(); newNode = newNode.WithTriviaFrom(literalExpression); return(await document.ReplaceNodeAsync(literalExpression, newNode, cancellationToken).ConfigureAwait(false)); }
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 static async Task ComputeRefactoringAsync(RefactoringContext context, LiteralExpressionSyntax literalExpression) { if (literalExpression.IsKind(SyntaxKind.StringLiteralExpression) && literalExpression.Token.ValueText.Length == 1) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); if (semanticModel.ContainsDiagnostic(CSharpErrorCodes.CannotImplicitlyConvertType, literalExpression.Span, context.CancellationToken)) { context.RegisterRefactoring( "Replace string literal with character literal", cancellationToken => RefactorAsync(context.Document, literalExpression, cancellationToken)); } } }
public void Append(LiteralExpressionSyntax stringLiteral) { if (stringLiteral == null) { return; } if (!stringLiteral.IsKind(SyntaxKind.StringLiteralExpression)) { throw new ArgumentException("", nameof(stringLiteral)); } StringLiteralExpressionInfo literalInfo = SyntaxInfo.StringLiteralExpressionInfo(stringLiteral); bool isVerbatim = literalInfo.IsVerbatim; if (IsVerbatim == isVerbatim) { string text = literalInfo.Text; int length = text.Length; if (length == 0) { return; } int startIndex = StringBuilder.Length; if (isVerbatim) { StringBuilder.Append(text, 2, length - 3); } else { StringBuilder.Append(text, 1, length - 2); } if (IsInterpolated) { StringBuilder.Replace("{", "{{", startIndex); StringBuilder.Replace("}", "}}", startIndex); } } else { Append(literalInfo.ValueText); } }
private static ReturnStatementSyntax CreateReturnStatement(IfStatementSyntax ifStatement) { LiteralExpressionSyntax booleanLiteral = SimplifyIfStatementToReturnStatementAnalyzer.GetBooleanLiteral(ifStatement.Statement); ExpressionSyntax expression = ifStatement.Condition; if (booleanLiteral.IsKind(SyntaxKind.FalseLiteralExpression)) { expression = expression.Negate(); } return(SyntaxFactory.ReturnStatement( SyntaxFactory.Token(SyntaxKind.ReturnKeyword).WithTrailingSpace(), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken))); }
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)); }
internal static HexNumericLiteralExpressionInfo Create(LiteralExpressionSyntax literalExpression) { if (literalExpression == null) return default; if (!literalExpression.IsKind(SyntaxKind.NumericLiteralExpression)) return default; SyntaxToken token = literalExpression.Token; string text = token.Text; if (!text.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) return default; return new HexNumericLiteralExpressionInfo(literalExpression, token); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { this.IsAttributeArgument = node.Parent.IsKind(SyntaxKind.AttributeArgument); if (node.IsKind(SyntaxKind.StringLiteralExpression) && !IsParameterDefaultArgument(node) && !this.IsAttributeArgument && !IsConstVariableDeclaration(node)) { if (string.IsNullOrEmpty(node.Token.ValueText)) { this.addedAnnotations = true; return SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), SyntaxFactory.IdentifierName("Empty")); } } return base.VisitLiteralExpression(node); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { var pattern = $"[^\\w](?<before>{this.before}[^\\w])"; if (node.IsKind(SyntaxKind.StringLiteralExpression) && Regex.IsMatch(node.Token.ValueText, pattern)) { return(node.Update( SyntaxFactory.Literal( Regex.Replace(node.Token.Text, this.before, UpdateMatch), Regex.Replace(node.Token.ValueText, this.before, UpdateMatch)))); } return(base.VisitLiteralExpression(node)); string UpdateMatch(Match match) { return(match.Value.Replace(this.before !, this.after)); } }