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