private void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var whereInvoke = (InvocationExpressionSyntax)context.Node;
if (GetNameOfTheInvokedMethod(whereInvoke) != "Where")
{
return;
}
var nextMethodInvoke = whereInvoke.Parent.
FirstAncestorOrSelf <InvocationExpressionSyntax>();
var candidate = GetNameOfTheInvokedMethod(nextMethodInvoke);
if (!supportedMethods.Contains(candidate))
{
return;
}
if (nextMethodInvoke.ArgumentList.Arguments.Any())
{
return;
}
var diagnostic = Diagnostic.Create(Rule, GetNameExpressionOfTheInvokedMethod(whereInvoke).GetLocation(), candidate);
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var objectCreationExpression = (ObjectCreationExpressionSyntax)context.Node;
var type = objectCreationExpression.Type;
var typeSymbol = context.SemanticModel.GetSymbolInfo(type).Symbol as ITypeSymbol;
if (!typeSymbol?.ToString().EndsWith("System.ArgumentException") ?? true) return;
var argumentList = objectCreationExpression.ArgumentList as ArgumentListSyntax;
if ((argumentList?.Arguments.Count ?? 0) < 2) return;
var paramNameLiteral = argumentList.Arguments[1].Expression as LiteralExpressionSyntax;
if (paramNameLiteral == null) return;
var paramNameOpt = context.SemanticModel.GetConstantValue(paramNameLiteral);
if (!paramNameOpt.HasValue) return;
var paramName = paramNameOpt.Value as string;
IList<string> parameters;
if (IsParamNameCompatibleWithCreatingContext(objectCreationExpression, paramName, out parameters)) return;
var props = parameters.ToImmutableDictionary(p => $"param{p}", p => p);
var diagnostic = Diagnostic.Create(Rule, paramNameLiteral.GetLocation(), props.ToImmutableDictionary(), paramName);
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var catchStatement = (CatchClauseSyntax)context.Node;
var block = catchStatement.Block;
if (block == null)
{
return;
}
var hasToDoComments =
block.DescendantTrivia().Any(trivia =>
trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) &&
IsToDoComment(trivia.ToString())
);
if (!hasToDoComments)
{
return;
}
var diagnostic = Diagnostic.Create(DiagnosticDescriptors.TodoCommentOnExceptionHandler, catchStatement.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
if (localDeclaration.IsConst) return;
var variableDeclaration = localDeclaration.ChildNodes()
.OfType<VariableDeclarationSyntax>()
.FirstOrDefault();
if (variableDeclaration.Type.IsVar) return;
var semanticModel = context.SemanticModel;
var variableTypeName = localDeclaration.Declaration.Type;
var variableType = semanticModel.GetTypeInfo(variableTypeName).ConvertedType;
foreach (var variable in variableDeclaration.Variables)
{
if (variable.Initializer == null) return;
var conversion = semanticModel.ClassifyConversion(variable.Initializer.Value, variableType);
if (!conversion.IsIdentity) return;
}
var diagnostic = Diagnostic.Create(Rule, variableDeclaration.Type.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeMethod(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var method = context.Node as MethodDeclarationSyntax;
if (!method.Identifier.Text.EndsWith("Async"))
{
return;
}
if (method.Modifiers.Any(m => m.Text == "async"))
{
return;
}
var returnType = context.SemanticModel.GetSymbolInfo(method.ReturnType).Symbol as INamedTypeSymbol;
if (returnType != null)
{
if (returnType.ToString() == "System.Threading.Tasks.Task" ||
(returnType.IsGenericType && returnType.ConstructedFrom.ToString() == "System.Threading.Tasks.Task<TResult>"))
{
return;
}
}
var diagnostic = Diagnostic.Create(Rule, method.Identifier.GetLocation(), method.Identifier.Text);
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration);
if (methodSymbol.DeclaredAccessibility != Accessibility.Private)
{
return;
}
if (IsMethodUsed(methodDeclaration, context.SemanticModel))
{
return;
}
if (IsMainMethodEntryPoint(methodDeclaration, context.SemanticModel))
{
return;
}
if (methodDeclaration.Modifiers.Any(SyntaxKind.ExternKeyword))
{
return;
}
var props = new Dictionary <string, string> {
{ "identifier", methodDeclaration.Identifier.Text }
}.ToImmutableDictionary();
var diagnostic = Diagnostic.Create(Rule, methodDeclaration.GetLocation(), props);
context.ReportDiagnostic(diagnostic);
}
private void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var stringLiteral = context.Node as LiteralExpressionSyntax;
if (string.IsNullOrWhiteSpace(stringLiteral?.Token.ValueText))
{
return;
}
var parameters = GetParameters(stringLiteral);
if (!parameters.Any())
{
return;
}
var attribute = stringLiteral.FirstAncestorOfType <AttributeSyntax>();
var method = stringLiteral.FirstAncestorOfType(typeof(MethodDeclarationSyntax), typeof(ConstructorDeclarationSyntax)) as BaseMethodDeclarationSyntax;
if (attribute != null && method.AttributeLists.Any(a => a.Attributes.Contains(attribute)))
{
return;
}
if (!AreEqual(stringLiteral, parameters))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, stringLiteral.GetLocation(), stringLiteral.Token.Value);
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeInvocation(SyntaxNodeAnalysisContext context, Compilation compilation)
{
if (context.IsGenerated()) return;
var methodInvokeSyntax = context.Node as InvocationExpressionSyntax;
var childNodes = methodInvokeSyntax.ChildNodes();
var methodCaller = childNodes.OfType<MemberAccessExpressionSyntax>().FirstOrDefault();
if (methodCaller == null) return;
var argumentsCount = CountArguments(childNodes);
var classSymbol = GetCallerClassSymbol(context.SemanticModel, methodCaller.Expression);
if (classSymbol == null || !classSymbol.MightContainExtensionMethods) return;
var methodSymbol = GetCallerMethodSymbol(context.SemanticModel, methodCaller.Name, argumentsCount);
if (methodSymbol == null || !methodSymbol.IsExtensionMethod) return;
if (ContainsDynamicArgument(context.SemanticModel, childNodes)) return;
ExpressionSyntax invocationStatement;
if (methodInvokeSyntax.Parent.IsNotKind(SyntaxKind.ArrowExpressionClause))
{
invocationStatement = (methodInvokeSyntax.FirstAncestorOrSelfThatIsAStatement() as ExpressionStatementSyntax).Expression;
}
else
{
invocationStatement = methodInvokeSyntax.FirstAncestorOrSelfOfType<ArrowExpressionClauseSyntax>().Expression;
}
if (invocationStatement == null) return;
if (IsSelectingADifferentMethod(childNodes, methodCaller.Name, context.Node.SyntaxTree, methodSymbol, invocationStatement, compilation)) return;
context.ReportDiagnostic(Diagnostic.Create(Rule, methodCaller.GetLocation(), methodSymbol.Name, classSymbol.Name));
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var fieldDeclaration = context.Node as FieldDeclarationSyntax;
var variable = fieldDeclaration?.Declaration.Variables.LastOrDefault();
if (variable?.Initializer == null)
{
return;
}
var semanticModel = context.SemanticModel;
var fieldSymbol = semanticModel.GetDeclaredSymbol(variable) as IFieldSymbol;
if (!IsComplexValueType(semanticModel, fieldDeclaration))
{
return;
}
if (!CanBeMadeReadonly(fieldSymbol))
{
return;
}
ReportDiagnostic(context, variable, variable.Initializer.Value);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var method = (MethodDeclarationSyntax)context.Node;
if (method.Modifiers.Any(SyntaxKind.ExternKeyword))
{
return;
}
var contentParameter = method.ParameterList;
if (!contentParameter.Parameters.Any() || contentParameter.Parameters.Count <= 3)
{
return;
}
if (contentParameter.Parameters.SelectMany(parameter => parameter.Modifiers)
.Any(modifier => modifier.IsKind(SyntaxKind.RefKeyword) ||
modifier.IsKind(SyntaxKind.OutKeyword) ||
modifier.IsKind(SyntaxKind.ThisKeyword) ||
modifier.IsKind(SyntaxKind.ParamsKeyword)))
{
return;
}
if (method.Body?.ChildNodes().Count() > 0)
{
return;
}
var diagnostic = Diagnostic.Create(Rule, contentParameter.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var addExpression = (BinaryExpressionSyntax)context.Node;
var hasInvocationExpression = addExpression.ChildNodesAndTokens().Any(x => x.IsKind(SyntaxKind.InvocationExpression));
//string concatenation must have an InvocationExpression
if (!hasInvocationExpression)
{
return;
}
var invocationExpressionsThatHaveToStringCall = GetInvocationExpressionsThatHaveToStringCall(addExpression);
var redundantToStringCalls = FilterInvocationsThatAreRedundant(invocationExpressionsThatHaveToStringCall, addExpression, context.SemanticModel, context.CancellationToken);
foreach (var expression in redundantToStringCalls)
{
var lastDot = expression.Expression.ChildNodesAndTokens().Last(x => x.IsKind(SyntaxKind.DotToken));
var toStringTextSpan = new TextSpan(lastDot.Span.Start, expression.ArgumentList.Span.End - lastDot.Span.Start);
var diagnostic = Diagnostic.Create(Rule, Location.Create(context.Node.SyntaxTree, toStringTextSpan));
context.ReportDiagnostic(diagnostic);
}
}
private void analyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
if (methodDeclaration.Modifiers.Any(m => m.Kind() == SyntaxKind.StaticKeyword))
{
return;
}
if (!methodDeclaration.Modifiers.Any(m => m.Kind() == SyntaxKind.PrivateKeyword))
{
return;
}
var firstCharacter = methodDeclaration.Identifier.Text[0];
if (char.IsUpper(firstCharacter))
{
context.ReportDiagnostic(Diagnostic.Create(rule, getReportLocation(methodDeclaration), methodDeclaration.Identifier.Text));
}
}
private static void AnalyzeMethod(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var method = (MethodDeclarationSyntax)context.Node;
if (method.Identifier.ToString().EndsWith("Async")) return;
if (method.Modifiers.Any(SyntaxKind.NewKeyword, SyntaxKind.OverrideKeyword)) return;
var errorMessage = method.Identifier.ToString() + "Async";
var diag = Diagnostic.Create(Rule, method.Identifier.GetLocation(), errorMessage);
if (method.Modifiers.Any(SyntaxKind.AsyncKeyword))
{
context.ReportDiagnostic(diag);
return;
}
var returnType = context.SemanticModel.GetSymbolInfo(method.ReturnType).Symbol as INamedTypeSymbol;
if (returnType == null) return;
if (returnType.ToString() == "System.Threading.Tasks.Task" ||
(returnType.IsGenericType && returnType.ConstructedFrom.ToString() == "System.Threading.Tasks.Task<TResult>"))
{
context.ReportDiagnostic(diag);
}
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var throwStatement = (ThrowStatementSyntax)context.Node;
var ident = throwStatement.Expression as IdentifierNameSyntax;
if (ident == null)
{
return;
}
var exSymbol = context.SemanticModel.GetSymbolInfo(ident).Symbol as ILocalSymbol;
if (exSymbol == null)
{
return;
}
var catchClause = context.Node.Parent.AncestorsAndSelf().OfType <CatchClauseSyntax>().FirstOrDefault();
if (catchClause == null)
{
return;
}
var catchExSymbol = context.SemanticModel.GetDeclaredSymbol(catchClause.Declaration);
if (!catchExSymbol.Equals(exSymbol))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, throwStatement.GetLocation(), "Throwing the same exception that was caught will loose the original stack trace.");
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeMethod(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var method = (MethodDeclarationSyntax)context.Node;
if (method.Identifier.ToString().EndsWith("Async"))
{
return;
}
var errorMessage = method.Identifier.ToString() + "Async";
var diag = Diagnostic.Create(Rule, method.Identifier.GetLocation(), errorMessage);
if (method.Modifiers.Any(SyntaxKind.AsyncKeyword))
{
context.ReportDiagnostic(diag);
return;
}
var returnType = context.SemanticModel.GetSymbolInfo(method.ReturnType).Symbol as INamedTypeSymbol;
if (returnType == null)
{
return;
}
if (returnType.ToString() == "System.Threading.Tasks.Task" ||
(returnType.IsGenericType && returnType.ConstructedFrom.ToString() == "System.Threading.Tasks.Task<TResult>"))
{
context.ReportDiagnostic(diag);
}
}
private static void AnalyzeConstructor(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var constructorMethod = (ConstructorDeclarationSyntax)context.Node;
var type = constructorMethod.FirstAncestorOrSelf<TypeDeclarationSyntax>();
if (type == null || !(type is ClassDeclarationSyntax || type is StructDeclarationSyntax)) return;
var parameters = constructorMethod.ParameterList.Parameters;
if (constructorMethod.Body == null) return;
var analysis = context.SemanticModel.AnalyzeDataFlow(constructorMethod.Body);
if (!analysis.Succeeded) return;
foreach (var par in parameters)
{
var parSymbol = context.SemanticModel.GetDeclaredSymbol(par);
if(!analysis.ReadInside.Any(s => s.Equals(parSymbol)))
{
var parameterName = par.Identifier.Text;
var properties = new Dictionary<string, string> { { nameof(parameterName), parameterName } }.ToImmutableDictionary();
var diag = Diagnostic.Create(Rule, par.GetLocation(), properties, parameterName);
context.ReportDiagnostic(diag);
}
}
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var mainConstrutor = new MethodInformation(
nameof(Uri),
"System.Uri.Uri(string)",
args =>
{
{
if (args[0] == null)
{
return;
}
new Uri(args[0].ToString());
}
}
);
var constructorWithUriKind = new MethodInformation(
nameof(Uri),
"System.Uri.Uri(string, System.UriKind)",
args =>
{
if (args[0] == null)
{
return;
}
new Uri(args[0].ToString(), (UriKind)args[1]);
}
);
var checker = new MethodChecker(context, Rule);
checker.AnalyzeConstructor(mainConstrutor);
checker.AnalyzeConstructor(constructorWithUriKind);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var catchStatement = (CatchClauseSyntax)context.Node;
if (catchStatement == null || catchStatement.Declaration != null)
{
return;
}
if (catchStatement.Block?.Statements.Count == 0)
{
return; // there is another analyzer for this: EmptyCatchBlock
}
if (catchStatement.Block != null)
{
// Allow empty catch when the block ends with a throw.
var controlFlow = context.SemanticModel.AnalyzeControlFlow(catchStatement.Block);
if (!controlFlow.EndPointIsReachable &&
controlFlow.ExitPoints.All(i => i.IsKind(SyntaxKind.ThrowStatement)))
{
return;
}
}
var diagnostic = Diagnostic.Create(Rule, catchStatement.GetLocation(), "Consider adding an Exception to the catch.");
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var invocationExpression = (InvocationExpressionSyntax)context.Node;
var memberExpresion = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (memberExpresion?.Name?.ToString() != "Match") return;
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberExpresion).Symbol;
if (memberSymbol?.ToString() != "System.Text.RegularExpressions.Regex.Match(string, string)") return;
var argumentList = invocationExpression.ArgumentList as ArgumentListSyntax;
if ((argumentList?.Arguments.Count ?? 0) != 2) return;
var regexLiteral = argumentList.Arguments[1].Expression as LiteralExpressionSyntax;
if (regexLiteral == null) return;
var regexOpt = context.SemanticModel.GetConstantValue(regexLiteral);
var regex = regexOpt.Value as string;
try
{
System.Text.RegularExpressions.Regex.Match("", regex);
}
catch (ArgumentException e)
{
var diag = Diagnostic.Create(Rule, regexLiteral.GetLocation(), e.Message);
context.ReportDiagnostic(diag);
}
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var ctor = (ConstructorDeclarationSyntax)context.Node;
if (!ctor.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword)))
{
return;
}
var @class = ctor.Ancestors().FirstOrDefault() as ClassDeclarationSyntax;
if (@class == null)
{
return;
}
if ([email protected](m => m.IsKind(SyntaxKind.AbstractKeyword)))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, ctor.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var comparison = (BinaryExpressionSyntax)context.Node;
// Only handle the case where both operands of type bool; other cases involve
// too much complexity to be able to deliver an accurate diagnostic confidently.
var leftType = context.SemanticModel.GetTypeInfo(comparison.Left).Type;
var rightType = context.SemanticModel.GetTypeInfo(comparison.Right).Type;
if (!IsBoolean(leftType) || !IsBoolean(rightType))
{
return;
}
var leftConstant = context.SemanticModel.GetConstantValue(comparison.Left);
var rightConstant = context.SemanticModel.GetConstantValue(comparison.Right);
if (!leftConstant.HasValue && !rightConstant.HasValue)
{
return;
}
var diagnostic = Diagnostic.Create(Rule, comparison.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var lambda = context.Node as ExpressionSyntax;
var invocation = GetInvocationIfAny(lambda);
if (invocation == null || invocation.ArgumentList.Arguments.Count == 0) return;
var lambdaParameters = BuildParameters(lambda);
if (!MatchArguments(lambdaParameters, invocation.ArgumentList)) return;
var root = lambda.SyntaxTree.GetRoot();
var newRoot = root.ReplaceNode(lambda, invocation.Expression as ExpressionSyntax);
var semanticNode = GetNodeRootForAnalysis(lambda);
var newSemanticNode = newRoot.DescendantNodesAndSelf()
.Where(x => x.SpanStart == semanticNode.SpanStart && x.Span.OverlapsWith(context.Node.Span))
.LastOrDefault(x => x.Kind() == semanticNode.Kind());
if (newSemanticNode == null || ReplacementChangesSemantics(semanticNode, newSemanticNode, context.SemanticModel)) return;
var diagnostic = Diagnostic.Create(
Rule,
context.Node.GetLocation(),
invocation.Expression.ToString());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var @switch = (SwitchStatementSyntax)context.Node;
if ([email protected](HasBraces))
context.ReportDiagnostic(Diagnostic.Create(Rule, @switch.GetLocation()));
}
static void AnalyzeBaseMethodNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var methodDeclaration = (BaseMethodDeclarationSyntax)context.Node;
var body = methodDeclaration.Body;
if (body == null)
{
return;
}
if (body.Statements.Count != 1)
{
return;
}
var returnStatement = body.Statements[0] as ReturnStatementSyntax;
if (returnStatement == null)
{
return;
}
var diagnostic = Diagnostic.Create(Rule, methodDeclaration.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyze(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var typeDeclarationSyntax = context.Node as TypeDeclarationSyntax;
if (!CanOrder(typeDeclarationSyntax)) return;
context.ReportDiagnostic(Diagnostic.Create(Rule, typeDeclarationSyntax.Identifier.GetLocation()));
}
private static void AnalyzeClass(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var invocationExpression = (PropertyDeclarationSyntax)context.Node;
var semanticModel = context.SemanticModel;
if (invocationExpression.AccessorList == null || invocationExpression.AccessorList.Accessors.Count <= 1)
{
return;
}
var setAcessor = (invocationExpression.AccessorList.Accessors[0].Keyword.Text == "set") ? invocationExpression.AccessorList.Accessors[0] : invocationExpression.AccessorList.Accessors[1];
if (setAcessor.Modifiers.Count != 0)
{
return;
}
var error = string.Format(MessageFormat, MessageFormat);
var diag = Diagnostic.Create(Rule, invocationExpression.GetLocation(), error);
context.ReportDiagnostic(diag);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var @for = (ForStatementSyntax)context.Node;
if (@for.Declaration == null && @for.Initializers.Count == 0)
{
return;
}
if (@for.Declaration != null && @for.Declaration.Variables.Count != 1)
{
return;
}
if (!HasAcceptableIncrementors(@for))
{
return;
}
if (!HasConditionCompatibleWithTheIncrementor(@for))
{
return;
}
if (!AreDeclarationConditionAndIncrementorUsingTheSameVariable(@for))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, @for.GetLocation(), IsPostIncrement(@for.Incrementors[0]) ? "decrement" : "increment");
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var invocation = (InvocationExpressionSyntax)context.Node;
var identifier = invocation.Expression as IdentifierNameSyntax;
if (identifier == null)
{
return;
}
if (context.Node.Parent.GetType().Name == nameof(ArrowExpressionClauseSyntax))
{
return;
}
var typeInfo = context.SemanticModel.GetTypeInfo(identifier, context.CancellationToken);
if (typeInfo.ConvertedType?.BaseType == null)
{
return;
}
var symbol = context.SemanticModel.GetSymbolInfo(identifier).Symbol;
if (typeInfo.ConvertedType.BaseType.Name != typeof(MulticastDelegate).Name ||
symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter || symbol.IsReadOnlyAndInitializedForCertain(context))
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.GetLocation(), identifier.Identifier.Text));
}
private void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var expression = context.Node as BinaryExpressionSyntax;
if (expression == null)
{
return;
}
if (HasErrors(context.SemanticModel, expression))
{
return;
}
var nodeToReportDiagnosticOn = expression.Parent is ParenthesizedExpressionSyntax ? expression.Parent : expression;
if (IsPartOfALargerBinaryExpression(nodeToReportDiagnosticOn))
{
return;
}
if (!AreLeftAndRightLiterals(expression))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, nodeToReportDiagnosticOn.GetLocation(), nodeToReportDiagnosticOn.ToString());
context.ReportDiagnostic(diagnostic);
}
public static void AnalyzeFormatInvocation(SyntaxNodeAnalysisContext context, string methodName, string methodOverloadSignature, string methodWithArraySignature, DiagnosticDescriptor rule)
{
if (context.IsGenerated()) return;
var invocationExpression = (InvocationExpressionSyntax)context.Node;
var memberExpresion = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (memberExpresion?.Name?.ToString() != methodName) return;
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberExpresion).Symbol;
if (memberSymbol == null) return;
if (!memberSymbol.ToString().StartsWith(methodOverloadSignature)) return;
var argumentList = invocationExpression.ArgumentList as ArgumentListSyntax;
if (argumentList?.Arguments.Count < 2) return;
if (!argumentList.Arguments[0]?.Expression?.IsKind(SyntaxKind.StringLiteralExpression) ?? false) return;
if (memberSymbol.ToString() == methodWithArraySignature && argumentList.Arguments.Skip(1).Any(a => context.SemanticModel.GetTypeInfo(a.Expression).Type.TypeKind == TypeKind.Array)) return;
var formatLiteral = (LiteralExpressionSyntax)argumentList.Arguments[0].Expression;
var format = (string)context.SemanticModel.GetConstantValue(formatLiteral).Value;
var formatArgs = Enumerable.Range(1, argumentList.Arguments.Count - 1).Select(i => new object()).ToArray();
try
{
string.Format(format, formatArgs);
}
catch (FormatException)
{
return;
}
var diag = Diagnostic.Create(rule, invocationExpression.GetLocation());
context.ReportDiagnostic(diag);
}
private void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var invocation = (InvocationExpressionSyntax)context.Node;
var identifier = invocation.Expression as IdentifierNameSyntax;
if (identifier == null)
{
return;
}
var typeInfo = context.SemanticModel.GetTypeInfo(identifier, context.CancellationToken);
if (typeInfo.ConvertedType?.BaseType == null)
{
return;
}
var symbol = context.SemanticModel.GetSymbolInfo(identifier).Symbol;
if (typeInfo.ConvertedType.BaseType.Name != typeof(MulticastDelegate).Name || symbol is ILocalSymbol)
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.GetLocation(), identifier.Identifier.Text));
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var invocation = (InvocationExpressionSyntax)context.Node;
var identifier = invocation.Expression as IdentifierNameSyntax;
if (identifier == null) return;
var typeInfo = context.SemanticModel.GetTypeInfo(identifier, context.CancellationToken);
if (typeInfo.ConvertedType?.BaseType == null) return;
if (typeInfo.ConvertedType.BaseType.Name != typeof(MulticastDelegate).Name) return;
var symbol = context.SemanticModel.GetSymbolInfo(identifier).Symbol;
if (symbol is ILocalSymbol) return;
var invokedMethodSymbol = (typeInfo.ConvertedType as INamedTypeSymbol)?.DelegateInvokeMethod;
if (invokedMethodSymbol == null) return;
if (HasCheckForNullThatReturns(invocation, context.SemanticModel, symbol)) return;
if (IsInsideANullCheck(invocation, context.SemanticModel, symbol)) return;
if (IsPartOfATernaryThatChecksForNull(invocation, context.SemanticModel, symbol)) return;
if (IsPartOfALogicalOrThatChecksForNull(invocation, context.SemanticModel, symbol)) return;
if (IsPartOfALogicalAndThatChecksForNotNull(invocation, context.SemanticModel, symbol)) return;
if (symbol.IsReadOnlyAndInitializedForCertain(context)) return;
context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.GetLocation(), identifier.Identifier.Text));
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
if (localDeclaration.IsConst) return;
var variableDeclaration = localDeclaration.ChildNodes()
.OfType<VariableDeclarationSyntax>()
.FirstOrDefault();
if (variableDeclaration.Type.IsVar) return;
var isDynamic = (variableDeclaration.Type as IdentifierNameSyntax)?.Identifier.ValueText == "dynamic";
var semanticModel = context.SemanticModel;
var variableTypeName = localDeclaration.Declaration.Type;
var variableType = semanticModel.GetTypeInfo(variableTypeName).ConvertedType;
foreach (var variable in variableDeclaration.Variables)
{
if (variable.Initializer == null) return;
var conversion = semanticModel.ClassifyConversion(variable.Initializer.Value, variableType);
if (!conversion.IsIdentity) return;
if (isDynamic)
{
var expressionReturnType = semanticModel.GetTypeInfo(variable.Initializer.Value);
if (expressionReturnType.Type.SpecialType == SpecialType.System_Object) return;
}
}
var rule = variableType.IsPrimitive() ? RulePrimitives : RuleNonPrimitives;
var diagnostic = Diagnostic.Create(rule, variableDeclaration.Type.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var ctor = (ConstructorDeclarationSyntax)context.Node;
if (!ctor.Modifiers.Any(SyntaxKind.StaticKeyword))
{
return;
}
if (ctor.Body == null)
{
return;
}
var @throw = ctor.Body.ChildNodes().OfType <ThrowStatementSyntax>().FirstOrDefault();
if (@throw == null)
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Rule, @throw.GetLocation(), ctor.Identifier.Text));
}
private static void AnalyzeConstructor(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var constructorMethod = (ConstructorDeclarationSyntax)context.Node;
var parameters = constructorMethod.ParameterList.Parameters;
if (constructorMethod.Body == null)
{
return;
}
var analysis = context.SemanticModel.AnalyzeDataFlow(constructorMethod.Body);
if (!analysis.Succeeded)
{
return;
}
foreach (var par in parameters)
{
var parSymbol = context.SemanticModel.GetDeclaredSymbol(par);
if (!analysis.ReadInside.Any(s => s.Equals(parSymbol)))
{
var parameterName = par.Identifier.Text;
var properties = new Dictionary <string, string> {
{ nameof(parameterName), parameterName }
}.ToImmutableDictionary();
var diag = Diagnostic.Create(Rule, par.GetLocation(), properties, parameterName);
context.ReportDiagnostic(diag);
}
}
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var invocationExpression = (InvocationExpressionSyntax)context.Node;
var memberExpression = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (memberExpression?.Name.ToString() != "IsMatch")
{
return;
}
var methodSymbol = context.SemanticModel.GetSymbolInfo(memberExpression).Symbol;
if (methodSymbol?.ContainingType.ToString() != "System.Text.RegularExpressions.Regex" || methodSymbol.IsStatic)
{
return;
}
if (!(memberExpression.Expression is IdentifierNameSyntax))
{
return;
}
var variableSymbol = context.SemanticModel.GetSymbolInfo(((IdentifierNameSyntax)memberExpression.Expression).Identifier.Parent).Symbol;
if (variableSymbol?.Kind != SymbolKind.Local)
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Rule, invocationExpression.GetLocation()));
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var @else = (ElseClauseSyntax)context.Node;
if (((@else.Parent as IfStatementSyntax)?.Statement as BlockSyntax)?.Statements.Count == 0)
{
return;
}
if (@else.Statement == null)
{
return;
}
var elseBlock = @else.Statement as BlockSyntax;
if (elseBlock == null)
{
return;
}
if (elseBlock.Statements.Count > 0)
{
return;
}
var diagnostic = Diagnostic.Create(Rule, @else.GetLocation(), MessageFormat);
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var ifStatement = context.Node as IfStatementSyntax;
if (ifStatement == null) return;
if (ifStatement.Else == null) return;
var blockIf = ifStatement.Statement as BlockSyntax;
var blockElse = ifStatement.Else.Statement as BlockSyntax;
if ((blockIf == null || blockIf.Statements.Count == 1) &&
(blockElse == null || blockElse.Statements.Count == 1))
{
var statementInsideIf = ifStatement.Statement is BlockSyntax ? ((BlockSyntax)ifStatement.Statement).Statements.Single() : ifStatement.Statement;
var elseStatement = ifStatement.Else;
var statementInsideElse = elseStatement.Statement is BlockSyntax ? ((BlockSyntax)elseStatement.Statement).Statements.Single() : elseStatement.Statement;
if (statementInsideIf is ReturnStatementSyntax && statementInsideElse is ReturnStatementSyntax)
{
var diagnostic = Diagnostic.Create(RuleForIfWithReturn, ifStatement.IfKeyword.GetLocation(), "You can use a ternary operator.");
context.ReportDiagnostic(diagnostic);
return;
}
var expressionInsideIf = statementInsideIf as ExpressionStatementSyntax;
var expressionInsideElse = statementInsideElse as ExpressionStatementSyntax;
if (expressionInsideIf != null && expressionInsideIf.Expression.IsKind(SyntaxKind.SimpleAssignmentExpression) && expressionInsideElse != null && expressionInsideElse.Expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
var assignmentExpressionInsideIf = (AssignmentExpressionSyntax)expressionInsideIf.Expression;
var assignmentExpressionInsideElse = (AssignmentExpressionSyntax)expressionInsideElse.Expression;
var variableIdentifierInsideIf = assignmentExpressionInsideIf.Left as IdentifierNameSyntax;
var variableIdentifierInsideElse = assignmentExpressionInsideElse.Left as IdentifierNameSyntax;
if (variableIdentifierInsideIf == null || variableIdentifierInsideElse == null
|| variableIdentifierInsideIf.Identifier.Text != variableIdentifierInsideElse.Identifier.Text) return;
var diagnostic = Diagnostic.Create(RuleForIfWithAssignment, ifStatement.IfKeyword.GetLocation(), "You can use a ternary operator.");
context.ReportDiagnostic(diagnostic);
}
}
}
private static void AnalyzeAssignment(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var semanticModel = context.SemanticModel;
var expressionStatement = context.Node as ExpressionStatementSyntax;
if (expressionStatement?.Expression?.IsNotKind(SyntaxKind.SimpleAssignmentExpression) ?? true)
{
return;
}
var assignmentExpression = (AssignmentExpressionSyntax)expressionStatement.Expression;
if (assignmentExpression.Right.IsNotKind(SyntaxKind.ObjectCreationExpression))
{
return;
}
if (((ObjectCreationExpressionSyntax)assignmentExpression.Right).Initializer?.IsKind(SyntaxKind.CollectionInitializerExpression) ?? false)
{
return;
}
var variableSymbol = semanticModel.GetSymbolInfo(assignmentExpression.Left).Symbol;
var assignmentExpressions = FindAssignmentExpressions(semanticModel, expressionStatement, variableSymbol);
if (!assignmentExpressions.Any())
{
return;
}
var diagnostic = Diagnostic.Create(RuleAssignment, expressionStatement.GetLocation(), "You can use initializers in here.");
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var node = (InvocationExpressionSyntax)context.Node;
IdentifierNameSyntax name = null;
var p0 = P.InvocationExpression(expression: P.MemberAccessExpression(name: P.IdentifierName("Where", action: x => name = x)));
if (!p0.IsMatch(context.Node))
{
return;
}
bool match1 = P.InvocationExpression(
argumentList: P.ArgumentList(
P.Argument(
expression: P.SimpleLambdaExpression())))
.IsMatch(node);
bool match2 = P.InvocationExpression(argumentList: P.ArgumentList(
P.Argument(
expression: P.ParenthesizedLambdaExpression(
parameterList: P.ParameterList(
P.Parameter())))))
.MatchAncestorsAndSelf(node).Count == 1;
if (!(match1 || match2))
{
return;
}
var nextMethodInvoke = node.Parent.
FirstAncestorOrSelf <InvocationExpressionSyntax>();
if (nextMethodInvoke == null)
{
return;
}
var candidate = GetNameOfTheInvokedMethod(nextMethodInvoke)?.ToString();
if (!supportedMethods.Contains(candidate))
{
return;
}
if (nextMethodInvoke.ArgumentList.Arguments.Any())
{
return;
}
var properties = new Dictionary <string, string> {
{ "methodName", candidate }
}.ToImmutableDictionary();
var diagnostic = Diagnostic.Create(Rule, name.GetLocation(), properties, candidate);
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var catchStatement = (CatchClauseSyntax)context.Node;
if (catchStatement?.Block?.Statements.Count != 0) return;
var diagnostic = Diagnostic.Create(Rule, catchStatement.GetLocation(), "Empty Catch Block.");
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNodeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var literal = context.Node as LiteralExpressionSyntax;
if (IsNoCandidateDiagnostic(literal)) return;
var diagnostic = Diagnostic.Create(Rule, literal.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNodeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var expression = context.Node as MemberAccessExpressionSyntax;
if (expression.ToString().ToLower() != "string.empty" || expression.Ancestors().OfType<AttributeArgumentSyntax>().Any())
return;
var diagnostic = Diagnostic.Create(Rule, expression.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNodeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var literal = context.Node as LiteralExpressionSyntax;
if (literal.ToString() != "\"\"" || literal.Ancestors().OfType<AttributeArgumentSyntax>().Any())
return;
var diagnostic = Diagnostic.Create(Rule, literal.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var ifStatement = (IfStatementSyntax)context.Node;
var nestedIf = ifStatement?.Statement.GetSingleStatementFromPossibleBlock() as IfStatementSyntax;
if (nestedIf == null || ifStatement.Else != null || nestedIf.Else != null) return;
var diagnostic = Diagnostic.Create(Rule, ifStatement.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var ifStatement = context.Node as IfStatementSyntax;
if (!ifStatement?.Condition.IsKind(SyntaxKind.LogicalAndExpression) ?? true) return;
if (ifStatement.Else != null) return;
var diagnostic = Diagnostic.Create(Rule, ifStatement.Condition.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var invocation = (InvocationExpressionSyntax)context.Node;
var identifier = invocation.Expression as IdentifierNameSyntax;
if (identifier == null)
{
return;
}
var typeInfo = context.SemanticModel.GetTypeInfo(identifier, context.CancellationToken);
if (typeInfo.ConvertedType?.BaseType == null)
{
return;
}
if (typeInfo.ConvertedType.BaseType.Name != typeof(MulticastDelegate).Name)
{
return;
}
var symbol = context.SemanticModel.GetSymbolInfo(identifier).Symbol;
if (symbol is ILocalSymbol)
{
return;
}
var invokedMethodSymbol = (typeInfo.ConvertedType as INamedTypeSymbol)?.DelegateInvokeMethod;
if (invokedMethodSymbol == null)
{
return;
}
//var cantFixWithElvis = false;
//if (!invokedMethodSymbol.ReturnsVoid && !invokedMethodSymbol.ReturnType.IsReferenceType)
// cantFixWithElvis = true;
if (HasCheckForNullThatReturns(invocation, context.SemanticModel, symbol))
{
return;
}
if (IsInsideANullCheck(invocation, context.SemanticModel, symbol))
{
return;
}
if (symbol.IsReadOnlyAndInitializedForCertain(context))
{
return;
}
//var properties = new Dictionary<string, string> { { nameof(cantFixWithElvis), cantFixWithElvis.ToString() } }.ToImmutableDictionary();
context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.GetLocation(), identifier.Identifier.Text));
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var objectCreation = context.Node as ObjectCreationExpressionSyntax;
if (objectCreation.Initializer != null && objectCreation.ArgumentList != null && !objectCreation.ArgumentList.Arguments.Any())
{
var diagnostic = Diagnostic.Create(Rule, objectCreation.ArgumentList.OpenParenToken.GetLocation(), "Remove unnecessary parenthesis.");
context.ReportDiagnostic(diagnostic);
}
}
private static void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var invocation = (InvocationExpressionSyntax)context.Node;
if (invocation.Parent?.IsKind(SyntaxKind.ExpressionStatement) ?? true) return;
var diagnosticToRaise = GetCorrespondingDiagnostic(context.SemanticModel, invocation);
if (diagnosticToRaise == null) return;
var diagnostic = Diagnostic.Create(diagnosticToRaise, GetName(invocation).GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var forStatement = context.Node as ForStatementSyntax;
if (forStatement == null) return;
if (forStatement.Declaration == null || forStatement.Condition == null || !forStatement.Incrementors.Any()
|| forStatement.Declaration.Variables.Count != 1 || forStatement.Incrementors.Count != 1) return;
var forBlock = forStatement.Statement as BlockSyntax;
if (forBlock == null) return;
var condition = forStatement.Condition as BinaryExpressionSyntax;
if (condition == null || !condition.IsKind(SyntaxKind.LessThanExpression)) return;
var arrayAccessor = condition.Right as MemberAccessExpressionSyntax;
if (arrayAccessor == null) return;
if (!arrayAccessor.IsKind(SyntaxKind.SimpleMemberAccessExpression)) return;
var semanticModel = context.SemanticModel;
var arrayId = semanticModel.GetSymbolInfo(arrayAccessor.Expression).Symbol;
if (arrayId == null) return;
if (!IsEnumerable(arrayId)) return;
var forVariable = forStatement.Declaration.Variables.First();
var literalExpression = forVariable.Initializer.Value as LiteralExpressionSyntax;
if (literalExpression == null || !literalExpression.IsKind(SyntaxKind.NumericLiteralExpression)) return;
if (literalExpression.Token.ValueText != "0") return;
var controlVarId = semanticModel.GetDeclaredSymbol(forVariable);
var otherUsesOfIndexToken = forBlock.DescendantTokens().Count(t =>
{
if (t.Text != forVariable.Identifier.Text) return false;
var elementAccess = t.GetAncestor<ElementAccessExpressionSyntax>();
if (elementAccess == null) return true;
var assignment = elementAccess.Parent as AssignmentExpressionSyntax;
if (assignment != null && assignment.Left == elementAccess) return true;
var accessIdentifier = elementAccess.Expression as IdentifierNameSyntax;
if (accessIdentifier == null) return true;
var identifierSymbol = semanticModel.GetSymbolInfo(accessIdentifier).Symbol;
if (identifierSymbol == null) return true;
return !identifierSymbol.Equals(arrayId);
});
if (otherUsesOfIndexToken != 0) return;
var iterableSymbols = (from s in forBlock.Statements.OfType<LocalDeclarationStatementSyntax>()
where s.Declaration.Variables.Count == 1
let declaration = s.Declaration.Variables.First()
where declaration?.Initializer?.Value is ElementAccessExpressionSyntax
let iterableSymbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(declaration)
let iterableType = iterableSymbol.Type
where !(iterableType.IsPrimitive() ^ iterableType.IsValueType)
let init = (ElementAccessExpressionSyntax)declaration.Initializer.Value
let initSymbol = semanticModel.GetSymbolInfo(init.ArgumentList.Arguments.First().Expression).Symbol
where controlVarId.Equals(initSymbol)
let someArrayInit = semanticModel.GetSymbolInfo(init.Expression).Symbol
where arrayId.Equals(someArrayInit)
select iterableSymbol).ToList();
if (!iterableSymbols.Any()) return;
if (IsIterationVariableWritten(semanticModel, forBlock, iterableSymbols)) return;
var diagnostic = Diagnostic.Create(Rule, forStatement.ForKeyword.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var awaitExpression = (AwaitExpressionSyntax)context.Node;
var awaitedExpression = awaitExpression.Expression;
if (!IsTask(awaitedExpression, context))
return;
var diagnostic = Diagnostic.Create(Rule, awaitExpression.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var catchStatement = (CatchClauseSyntax)context.Node;
if (catchStatement == null || catchStatement.Declaration != null) return;
if (catchStatement.Block?.Statements.Count == 0) return; // there is another analizer for this: EmptyCatchBlock
var diagnostic = Diagnostic.Create(Rule, catchStatement.GetLocation(), "Consider put an Exception Class in catch.");
context.ReportDiagnostic(diagnostic);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var objectCreation = context.Node as ObjectCreationExpressionSyntax;
if (objectCreation.Initializer != null && !objectCreation.Initializer.Expressions.Any())
{
var diagnostic = Diagnostic.Create(Rule, objectCreation.Initializer.OpenBraceToken.GetLocation(), "Remove empty object initializer.");
context.ReportDiagnostic(diagnostic);
}
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var @else = (ElseClauseSyntax)context.Node;
if (((@else.Parent as IfStatementSyntax)?.Statement as BlockSyntax)?.Statements.Count == 0) return;
if (@else.Statement == null) return;
var elseBlock = @else.Statement as BlockSyntax;
if (elseBlock == null) return;
if (elseBlock.Statements.Count > 0) return;
var diagnostic = Diagnostic.Create(Rule, @else.GetLocation(), MessageFormat);
context.ReportDiagnostic(diagnostic);
}
public static void AnalyzeFormatInvocation(SyntaxNodeAnalysisContext context, string methodName, string methodOverloadSignature, string methodWithArraySignature, DiagnosticDescriptor rule)
{
if (context.IsGenerated())
{
return;
}
var invocationExpression = (InvocationExpressionSyntax)context.Node;
var memberExpresion = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (memberExpresion?.Name?.ToString() != methodName)
{
return;
}
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberExpresion).Symbol;
if (memberSymbol == null)
{
return;
}
if (!memberSymbol.ToString().StartsWith(methodOverloadSignature))
{
return;
}
var argumentList = invocationExpression.ArgumentList as ArgumentListSyntax;
if (argumentList?.Arguments.Count < 2)
{
return;
}
if (!argumentList.Arguments[0]?.Expression?.IsKind(SyntaxKind.StringLiteralExpression) ?? false)
{
return;
}
if (memberSymbol.ToString() == methodWithArraySignature && argumentList.Arguments.Skip(1).Any(a => context.SemanticModel.GetTypeInfo(a.Expression).Type.TypeKind == TypeKind.Array))
{
return;
}
var formatLiteral = (LiteralExpressionSyntax)argumentList.Arguments[0].Expression;
var format = (string)context.SemanticModel.GetConstantValue(formatLiteral).Value;
var formatArgs = Enumerable.Range(1, argumentList.Arguments.Count - 1).Select(i => new object()).ToArray();
try
{
string.Format(format, formatArgs);
}
catch (FormatException)
{
return;
}
var diag = Diagnostic.Create(rule, invocationExpression.GetLocation());
context.ReportDiagnostic(diag);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
if (localDeclaration.IsConst)
{
return;
}
var variableDeclaration = localDeclaration.ChildNodes()
.OfType <VariableDeclarationSyntax>()
.FirstOrDefault();
if (variableDeclaration.Type.IsVar)
{
return;
}
var isDynamic = (variableDeclaration.Type as IdentifierNameSyntax)?.Identifier.ValueText == "dynamic";
var semanticModel = context.SemanticModel;
var variableTypeName = localDeclaration.Declaration.Type;
var variableType = semanticModel.GetTypeInfo(variableTypeName).ConvertedType;
foreach (var variable in variableDeclaration.Variables)
{
if (variable.Initializer == null)
{
return;
}
var conversion = semanticModel.ClassifyConversion(variable.Initializer.Value, variableType);
if (!conversion.IsIdentity)
{
return;
}
if (isDynamic)
{
var expressionReturnType = semanticModel.GetTypeInfo(variable.Initializer.Value);
if (expressionReturnType.Type.SpecialType == SpecialType.System_Object)
{
return;
}
}
}
var rule = variableType.IsPrimitive() ? RulePrimitives : RuleNonPrimitives;
var diagnostic = Diagnostic.Create(rule, variableDeclaration.Type.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private static void AnalyzeClass(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var invocationExpression = (InterfaceDeclarationSyntax)context.Node;
var semanticModel = context.SemanticModel;
var name = invocationExpression.Identifier.ToString().ToUpper();
if (name.StartsWith("I")) return;
var error = string.Format(MessageFormat, MessageFormat);
var diag = Diagnostic.Create(Rule, invocationExpression.GetLocation(), error);
context.ReportDiagnostic(diag);
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated())
{
return;
}
var invocation = (InvocationExpressionSyntax)context.Node;
var identifier = invocation.Expression as IdentifierNameSyntax;
if (identifier == null)
{
return;
}
var typeInfo = context.SemanticModel.GetTypeInfo(identifier, context.CancellationToken);
if (typeInfo.ConvertedType?.BaseType == null)
{
return;
}
if (typeInfo.ConvertedType.BaseType.Name != typeof(MulticastDelegate).Name)
{
return;
}
var symbol = context.SemanticModel.GetSymbolInfo(identifier).Symbol;
if (symbol is ILocalSymbol)
{
return;
}
var invokedMethodSymbol = (typeInfo.ConvertedType as INamedTypeSymbol)?.DelegateInvokeMethod;
if (invokedMethodSymbol == null)
{
return;
}
if (HasCheckForNullThatReturns(invocation, context.SemanticModel, symbol))
{
return;
}
if (IsInsideANullCheck(invocation, context.SemanticModel, symbol))
{
return;
}
if (symbol.IsReadOnlyAndInitializedForCertain(context))
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.GetLocation(), identifier.Identifier.Text));
}
private static void Analyzer(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var finalizer = (DestructorDeclarationSyntax)context.Node;
var body = finalizer.Body;
if (body == null) return;
if (body.DescendantNodes().Any(n => !n.IsKind(SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia))) return;
context.ReportDiagnostic(Diagnostic.Create(Rule, finalizer.GetLocation(), finalizer.Identifier.Text));
}
private static void AnalyzeObjectCreation(SyntaxNodeAnalysisContext context)
{
if (context.IsGenerated()) return;
var objectCreation = context.Node as ObjectCreationExpressionSyntax;
if (objectCreation == null) return;
if (objectCreation?.Parent is UsingStatementSyntax) return;
if (objectCreation?.Parent is ReturnStatementSyntax) return;
if (objectCreation.Ancestors().Any(i => i.IsAnyKind(
SyntaxKind.ThisConstructorInitializer,
SyntaxKind.BaseConstructorInitializer,
SyntaxKind.ObjectCreationExpression))) return;
var semanticModel = context.SemanticModel;
var type = semanticModel.GetSymbolInfo(objectCreation.Type).Symbol as INamedTypeSymbol;
if (type == null) return;
if (!type.AllInterfaces.Any(i => i.ToString() == "System.IDisposable")) return;
ISymbol identitySymbol = null;
StatementSyntax statement = null;
if (objectCreation.Parent.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
var assignmentExpression = (AssignmentExpressionSyntax)objectCreation.Parent;
identitySymbol = semanticModel.GetSymbolInfo(assignmentExpression.Left).Symbol;
if (identitySymbol?.Kind != SymbolKind.Local) return;
if (assignmentExpression.FirstAncestorOrSelf<MethodDeclarationSyntax>() == null) return;
var usingStatement = assignmentExpression.Parent as UsingStatementSyntax;
if (usingStatement != null) return;
statement = assignmentExpression.Parent as ExpressionStatementSyntax;
}
else if (objectCreation.Parent.IsKind(SyntaxKind.EqualsValueClause) && objectCreation.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator))
{
var variableDeclarator = (VariableDeclaratorSyntax)objectCreation.Parent.Parent;
var variableDeclaration = variableDeclarator?.Parent as VariableDeclarationSyntax;
identitySymbol = semanticModel.GetDeclaredSymbol(variableDeclarator);
if (identitySymbol == null) return;
var usingStatement = variableDeclaration?.Parent as UsingStatementSyntax;
if (usingStatement != null) return;
statement = variableDeclaration.Parent as LocalDeclarationStatementSyntax;
if ((statement?.FirstAncestorOrSelf<MethodDeclarationSyntax>()) == null) return;
}
else
{
var props = new Dictionary<string, string> { { "typeName", type.Name } }.ToImmutableDictionary();
context.ReportDiagnostic(Diagnostic.Create(Rule, objectCreation.GetLocation(), props, type.Name.ToString()));
return;
}
if (statement != null && identitySymbol != null)
{
var isDisposeOrAssigned = IsDisposedOrAssigned(semanticModel, statement, (ILocalSymbol)identitySymbol);
if (isDisposeOrAssigned) return;
var props = new Dictionary<string, string> { { "typeName", type.Name } }.ToImmutableDictionary();
context.ReportDiagnostic(Diagnostic.Create(Rule, objectCreation.GetLocation(), props, type.Name.ToString()));
}
}
