private static void ReportDiagnostic( SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalExpression, string identifier) { context.ReportDiagnostic( DiagnosticDescriptors.UseNameOfOperator, literalExpression.GetLocation(), ImmutableDictionary.CreateRange(new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("Identifier", identifier) })); string text = literalExpression.Token.Text; if (text.Length >= 2) { SyntaxTree syntaxTree = literalExpression.SyntaxTree; TextSpan span = literalExpression.Span; context.ReportDiagnostic( DiagnosticDescriptors.UseNameOfOperatorFadeOut, Location.Create(syntaxTree, new TextSpan(span.Start, (text[0] == '@') ? 2 : 1))); context.ReportDiagnostic( DiagnosticDescriptors.UseNameOfOperatorFadeOut, Location.Create(syntaxTree, new TextSpan(span.End - 1, 1))); } }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.CSharpKind() != SyntaxKind.StringLiteralExpression) { return(node); } var pos = node.GetLocation().GetMappedLineSpan(); var result = OnRewrite(pos.StartLinePosition.Line + 1, pos.StartLinePosition.Character + 1, Utils.EscapeString(node.Token.ValueText)); if (result == null) { return(node); } ExpressionSyntax newNode = null; foreach (var name in result.Split('.')) { if (newNode == null) { newNode = SyntaxFactory.IdentifierName(name); } else { newNode = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, newNode, SyntaxFactory.IdentifierName(name)); } } return(newNode.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia())); }
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); } }
internal static void Run(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalExpression) { //Report warning illgal in literal case try { var diagnostic = Diagnostic.Create(Rule, literalExpression.GetLocation()); context.ReportDiagnostic(diagnostic); } catch { } }
string LocationDiagnostics(int matchPosition) { var span = node.GetLocation().GetLineSpan(); return(string.Format( "{0} ({1},{2})", span.Path, span.StartLinePosition.Line + 1, span.StartLinePosition.Character + 1 + matchPosition)); }
private void AnalyzeNode(SyntaxNodeAnalysisContext context) { LiteralExpressionSyntax literal = (LiteralExpressionSyntax)context.Node; TypeInfo typeInfo = context.SemanticModel.GetTypeInfo(literal); if (typeInfo.ConvertedType.ToString() == "FixMath.NET.Fix64") { var diagnostic = Diagnostic.Create(Rule, literal.GetLocation(), "Numeric Literal should be replaced with static constant"); context.ReportDiagnostic(diagnostic); } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.NullLiteralExpression)) { TypeExpressionLocation = node.GetLocation(); } else { base.VisitLiteralExpression(node); } }
private static void CheckJsonValue(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalParameter, string json) { try { parseMethodInfo.Value.Invoke(null, new[] { json }); } catch (Exception ex) { var diag = Diagnostic.Create(Rule, literalParameter.GetLocation(), ex.InnerException.Message); context.ReportDiagnostic(diag); } }
private static void CheckJsonValue(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalParameter, string json) { try { parseMethodInfo.Value.Invoke(null, new[] { json }); } catch (Exception ex) { var diag = Diagnostic.Create(Rule, literalParameter.GetLocation(), ex.InnerException.Message); context.ReportDiagnostic(diag); } }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction( c => { LiteralExpressionSyntax literalNode = (LiteralExpressionSyntax)c.Node; if (IsUnnecessary(literalNode)) { c.ReportDiagnostic(Diagnostic.Create(Rule, literalNode.GetLocation(), literalNode.Token.ToString())); } }, SyntaxKind.TrueLiteralExpression, SyntaxKind.FalseLiteralExpression); }
private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalExpression, string text) { context.ReportDiagnostic( DiagnosticDescriptors.UseNameOfOperator, literalExpression.GetLocation(), text); text = literalExpression.Token.Text; if (text.Length >= 2) { ReportDiagnostic(context, literalExpression, new TextSpan(literalExpression.Span.Start, (text[0] == '@') ? 2 : 1)); ReportDiagnostic(context, literalExpression, new TextSpan(literalExpression.Span.End - 1, 1)); } }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.CSharpKind() != SyntaxKind.StringLiteralExpression) return node; var pos = node.GetLocation().GetMappedLineSpan(); var result = OnRewrite(pos.StartLinePosition.Line + 1, pos.StartLinePosition.Character + 1, Source.Lines[pos.StartLinePosition.Line].ToString(), node.Token.ValueText); if (result == null) return node; var names = result.Split('.'); ExpressionSyntax newNode = SyntaxFactory.IdentifierName(names.First()); foreach (var name in names.Skip(1)) { newNode = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, newNode, SyntaxFactory.IdentifierName(name)); } return newNode.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia()); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (entryNode is AnonymousFunctionExpressionSyntax && embeddedNode is AnonymousFunctionExpressionSyntax) { return; } if (_weComeFromMethod && _weInAnonymousMethod) { return; } if (node.IsParent <AnonymousObjectMemberDeclaratorSyntax>()) { return; } InsertLLOCMap(node.GetLocation()); base.VisitLiteralExpression(node); }
private static void HandleStringLiteral(SyntaxNodeAnalysisContext context) { LiteralExpressionSyntax literalExpression = (LiteralExpressionSyntax)context.Node; var token = literalExpression.Token; if (token.IsKind(SyntaxKind.StringLiteralToken)) { if (HasToBeConstant(literalExpression)) { return; } if (token.ValueText == string.Empty) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, literalExpression.GetLocation())); } } }
private void Analyze(SyntaxNodeAnalysisContext context) { LiteralExpressionSyntax stringLiteralExpressionNode = (LiteralExpressionSyntax)context.Node; // Get the text value of the string literal expression. string pathValue = stringLiteralExpressionNode.Token.ValueText; //if the character of the string do not match either of the characters : for windows and / for linux; no need to run regex, simply return. if (!pathValue[1].Equals(':') && !pathValue[0].Equals('/')) { return; } // If the pattern matches the text value, report the diagnostic. if (WindowsPattern.IsMatch(pathValue) || LinuxPattern.IsMatch(pathValue)) { Diagnostic diagnostic = Diagnostic.Create(Rule, stringLiteralExpressionNode.GetLocation()); context.ReportDiagnostic(diagnostic); } }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction( c => { LiteralExpressionSyntax literalNode = (LiteralExpressionSyntax)c.Node; if (!literalNode.IsPartOfStructuredTrivia() && !literalNode.Ancestors().Any(e => e.IsKind(SyntaxKind.VariableDeclarator) || e.IsKind(SyntaxKind.EnumDeclaration) || e.IsKind(SyntaxKind.Attribute)) && !Exceptions.Contains(literalNode.Token.Text)) { c.ReportDiagnostic(Diagnostic.Create(Rule, literalNode.GetLocation())); } }, SyntaxKind.NumericLiteralExpression); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { InsertLLOCMap(node.GetLocation()); base.VisitLiteralExpression(node); }