public Inspection Analyze(SyntaxNode node) { if (!(node is BlockSyntax root) || root.DescendantNodes().Any() || root.Parent is SimpleLambdaExpressionSyntax || root.Parent is LambdaExpressionSyntax || root.Parent is ParenthesizedLambdaExpressionSyntax) { return(null); } Description = "This code has a blank block to do nothing. Sometimes this means the code missed to implement here"; CodeReviewUrl = "https://confluence.devfactory.com/display/CodeReview/Blank+code+block"; if (root.Parent is IfStatementSyntax) { Description = "This method contains an unnecessary empty if statement"; Severity = Constants.SeverityType.Yellow.ToString(); CodeReviewUrl = "https://confluence.devfactory.com/display/CodeReview/Empty+and+unnecessary+if+statement"; } else if (root.Parent is CatchClauseSyntax) { Description = @"The exception is ignored (""swallowed"") by the try-catch block."; CodeReviewUrl = "https://confluence.devfactory.com/display/CodeReview/Catching+and+Ignoring+Exception"; } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (_model == null) { return(null); } if (!(node is ObjectCreationExpressionSyntax)) { return(null); } var symbolicInfo = _model.GetTypeInfo(node); if (symbolicInfo.Type == null) { return(null); } var isIDisposable = symbolicInfo .Type .AllInterfaces.Any(x => x.Name == nameof(IDisposable) || x.MetadataName == nameof(IDisposable)); return(isIDisposable ? Inspection.Create(this, node.LineNumber() + 1, node.ToFullString()) : null); }
public Inspection Analyze(SyntaxNode node) { if (!(node is MethodDeclarationSyntax method)) { return(null); } var attributes = method.AttributeLists.Where(x => x.Attributes.Any(y => y.Name.ToString() == "TestCase")).SelectMany(x => x.Attributes).ToList(); if (!attributes.Any()) { return(null); } if (attributes.Count == 1) { return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); } var firstAttribute = attributes.First(); for (var attrArgIndex = 0; attrArgIndex < firstAttribute.ArgumentList.Arguments.Count; attrArgIndex++) { if (attributes.Skip(1).All(x => x.ArgumentList.Arguments[attrArgIndex].ToString() == firstAttribute.ArgumentList.Arguments[attrArgIndex].ToString())) { return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); } } return(null); }
public Inspection Analyze(SyntaxNode node) { if (!(node is StructDeclarationSyntax)) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is EnumDeclarationSyntax root) || root.Members.Any(x => x.EqualsValue.Value.ToString() == "0")) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is SwitchStatementSyntax root) || root.DescendantNodes() .OfType <DefaultSwitchLabelSyntax>().Any()) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is ParameterListSyntax root) || root.Parent is ParenthesizedLambdaExpressionSyntax || root.Parameters.Count <= 7) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { var root = node as ObjectCreationExpressionSyntax; var exceptionWithoutContext = root?.Parent is ThrowStatementSyntax && !root.ArgumentList.Arguments.Any(); if (root == null || !exceptionWithoutContext) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is FieldDeclarationSyntax root) || root.Modifiers.ToString().Contains("private") || root.Modifiers.ToString().Contains("internal") || root.Modifiers.ToString().Contains("const") || root.Modifiers.ToString().Contains("static") || string.IsNullOrWhiteSpace(root.Modifiers.ToString()) || root.Declaration.Variables.Count > 1) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is IdentifierNameSyntax syntax) || !syntax.Identifier.ValueText.Equals("ShouldSatisfyAllConditions", StringComparison.InvariantCulture)) { return(null); } var invocation = node.Ancestors <InvocationExpressionSyntax>().FirstOrDefault(); if (invocation == null || invocation.ArgumentList.Arguments.Count > 1) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (_nodeLocations == null || !_nodeLocations.Any()) { return(null); } if (!(node is ParameterSyntax parameter)) { return(null); } return(_nodeLocations.All(x => x != parameter.Identifier.GetLocation()) ? null : Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode context) { if (!(context is UsingStatementSyntax node)) { return(null); } if (!node.Expression.ToString().Contains("ShimsContext.Create()")) { return(null); } return(node.Statement.ToString().Contains("Shim") ? null : Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is MethodDeclarationSyntax syntax) || syntax.DescendantNodes <IdentifierNameSyntax>() .Any(x => x.Identifier.ValueText.Equals("ShouldSatisfyAllConditions", StringComparison.InvariantCulture))) { return(null); } return(syntax.DescendantNodes <IdentifierNameSyntax>() .Count(x => x.Identifier.ValueText.StartsWith("ShouldBe") || x.Identifier.ValueText.StartsWith("ShouldNotBe") || x.Identifier.ValueText.StartsWith("ShouldThrow")) <= 2 ? null : Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (_nodeLocations == null || !_nodeLocations.Any()) { return(null); } if (!(node is VariableDeclaratorSyntax variable)) { return(null); } return(_nodeLocations.All(x => x != variable.Identifier.GetLocation()) ? null : Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is ForEachStatementSyntax root)) { return(null); } var enumerable = root.Expression.ToString(); if (!(enumerable.Contains(".ToArray()") || enumerable.Contains(".ToList()"))) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { var root = node as ClassDeclarationSyntax; var keywords = new[] { "Manager", "Processor", "Data", "Info" }; if (root != null && keywords.Any(x => root.Identifier.ValueText.EndsWith(x))) { return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); } return(null); }
public Inspection Analyze(SyntaxNode node) { if (!(node is MemberAccessExpressionSyntax)) { return(null); } if (!node.ToString().EndsWith("AllInstances")) { return(null); } var method = node.Ancestors <MethodDeclarationSyntax>().FirstOrDefault(); return(method?.DescendantNodes <ObjectCreationExpressionSyntax>() .Any(obj => node.ToString() == $"{obj.Type}.AllInstances") == true ? Inspection.Create(this, node.LineNumber() + 1, node.ToFullString()) : null); }
public Inspection Analyze(SyntaxNode node) { if (!(node is PropertyDeclarationSyntax property)) { return(null); } if (property.DescendantNodes <ArrowExpressionClauseSyntax>().Count < 4) { return(null); } if (!(property.DescendantNodes <InvocationExpressionSyntax>().Any() || property.DescendantNodes <ObjectCreationExpressionSyntax>().Any())) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is MemberAccessExpressionSyntax)) { return(null); } if (!node.ToString().Contains(".AllInstances.")) { return(null); } var method = node.Ancestors <MethodDeclarationSyntax>().FirstOrDefault(); return(method? .DescendantNodes <MemberAccessExpressionSyntax>() .Count(x => x.ToString() == node.ToString()) > 1 ? Inspection.Create(this, node.LineNumber() + 1, node.ToFullString()) : null); }
public Inspection Analyze(SyntaxNode node) { if (_model == null) { return(null); } if (!(node is PropertyDeclarationSyntax property)) { return(null); } var privateType = !(property.Modifiers.ToString().Contains(PublicModifier) || property.Modifiers.ToString().Contains(ProtectedModifier)); if (privateType || property.AccessorList == null || property.AccessorList.Accessors.Count == 1 && property.AccessorList.Accessors[0].ToFullString().Contains(Getter)) { return(null); } var symbolicInfo = _model.GetTypeInfo(node.ChildNodes().FirstOrDefault()); if (symbolicInfo.Type == null) { return(null); } var iEnumerable = symbolicInfo .Type .AllInterfaces.Any(x => x.Name == nameof(IEnumerable) || x.MetadataName == nameof(IEnumerable)); return(iEnumerable ? Inspection.Create(this, node.LineNumber() + 1, node.ToFullString()) : null); }
public Inspection Analyze(SyntaxNode node) { if (!(node is InitializerExpressionSyntax initializer)) { return(null); } if (!initializer.ChildNodes().All(y => y.Kind() == SyntaxKind.ObjectCreationExpression && (y as ObjectCreationExpressionSyntax)?.Type?.ToString() == "TestCaseData")) { return(null); } var testCases = initializer.ChildNodes().Cast <ObjectCreationExpressionSyntax>().ToList(); if (!testCases.Any()) { return(null); } if (testCases.Count == 1) { return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); } var firstAttribute = testCases.First(); for (var attrArgIndex = 0; attrArgIndex < firstAttribute.ArgumentList.Arguments.Count; attrArgIndex++) { if (testCases.Skip(1).All(x => x.ArgumentList.Arguments[attrArgIndex].ToString() == firstAttribute.ArgumentList.Arguments[attrArgIndex].ToString())) { return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); } } return(null); }
public Inspection Analyze(SyntaxNode node) { if (!(node is ParameterListSyntax root) || root.Parent is ParenthesizedLambdaExpressionSyntax || !root.Parameters.Any() || root.Parameters.All(x => { var type = x.Type.ToString(); return(type != BoolKeyword && type != BooleanKeyword); })) { return(null); } var method = node.Ancestors <MethodDeclarationSyntax>().FirstOrDefault(); if (method != null && method.AttributeLists.Any()) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { var root = node as IdentifierNameSyntax; var genericExceptions = new[] { "Exception", "ApplicationException", "SystemException", "ExecutionEngineException", "IndexOutOfRangeException", "NullReferenceException", "OutOfMemoryException" }; if (root == null || genericExceptions.All(x => root.Identifier.ValueText != x) || !(root.Parent is ObjectCreationExpressionSyntax && root.Parent.Parent is ThrowStatementSyntax)) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { if (!(node is FieldDeclarationSyntax field)) { return(null); } var privateField = !(field.Modifiers.ToString().Contains(PublicModifier) || field.Modifiers.ToString().Contains(ProtectedModifier)); if (privateField) { return(null); } var containConstant = field.Modifiers.ToString().Contains(ConstantModifier); if (!containConstant) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { var predefinedType = node as PredefinedTypeSyntax; var parameterType = node as ParameterSyntax; var genericType = node as GenericNameSyntax; var collectionTypes = new[] { "Enumerable", "ReadOnlyCollection", "Collection", "ReadOnlyList", "Dictionary", "List" }; if (predefinedType == null && genericType == null && parameterType == null) { return(null); } if (genericType?.Parent is ObjectCreationExpressionSyntax || genericType?.Parent is TypeOfExpressionSyntax || genericType?.Parent is CastExpressionSyntax || genericType?.Parent is BinaryExpressionSyntax || genericType?.Parent is TypeArgumentListSyntax || genericType?.Parent?.Parent is ArgumentSyntax || predefinedType?.Parent is ObjectCreationExpressionSyntax || predefinedType?.Parent is TypeOfExpressionSyntax || predefinedType?.Parent is BinaryExpressionSyntax || predefinedType?.Parent is TypeArgumentListSyntax || predefinedType?.Parent is CastExpressionSyntax || predefinedType?.Parent?.Parent is ArgumentSyntax || parameterType?.Parent is TypeOfExpressionSyntax) { return(null); } if (CheckPublicMethodOrField(genericType)) { return(null); } if (CheckPublicMethodOrField(predefinedType)) { return(null); } if (predefinedType?.IsVar == true || genericType?.IsVar == true) { return(null); } if (parameterType != null && !(parameterType.Modifiers.ToString().Contains(PublicModifier) || parameterType.Modifiers.ToString().Contains(ProtectedModifier))) { return(null); } var type = predefinedType?.ToString() ?? parameterType?.Type.ToString() ?? genericType.Identifier.ValueText ?? string.Empty; if (type.Contains(".")) { type = type .Split('.') .Last(); } if (!collectionTypes.Any(x => type.StartsWith(x))) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }
public Inspection Analyze(SyntaxNode node) { var root = node as IdentifierNameSyntax; const string valueKeyWord = "value"; var contextualKeywords = new[] { "add", "alias", "ascending", "async", "await", "by", "descending", "dynamic", "equals", "from", "get", "global", "group", "into", "join", "let", "nameof", "on", "orderby", "partial", "remove", "select", "set", valueKeyWord, "var", "when", "where", "yield" }; if (root == null || root.Parent is InvocationExpressionSyntax || root.Parent is VariableDeclarationSyntax || root.Parent is ForEachStatementSyntax || root.Parent is ForStatementSyntax || root.Parent is WhileStatementSyntax || root.Parent is SwitchStatementSyntax || root.Parent is DeclarationExpressionSyntax || root.Parent is TypeOfExpressionSyntax || root.Parent is MethodDeclarationSyntax || root.Parent is ParameterSyntax || root.Parent.Parent is GenericNameSyntax || contextualKeywords.All(x => x != root.Identifier.ValueText)) { return(null); } if (root.Ancestors().Any(x => x.IsKind(SyntaxKind.SetAccessorDeclaration)) && root.Identifier.ValueText == valueKeyWord) { return(null); } return(Inspection.Create(this, node.LineNumber() + 1, node.Parent.ToFullString())); }