Exemplo n.º 1
0
        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSyntaxNodeActionInNonGenerated(
                c =>
            {
                var lessThan = (BinaryExpressionSyntax)c.Node;
                if (ExpressionNumericConverter.TryGetConstantIntValue(lessThan.Left, out var constValue) &&
                    constValue == 0 &&
                    IsIndexOfCall(lessThan.Right, c.SemanticModel))
                {
                    c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, Location.Create(lessThan.SyntaxTree,
                                                                                         TextSpan.FromBounds(lessThan.Left.SpanStart, lessThan.OperatorToken.Span.End))));
                }
            },
                SyntaxKind.LessThanExpression);

            context.RegisterSyntaxNodeActionInNonGenerated(
                c =>
            {
                var greaterThan = (BinaryExpressionSyntax)c.Node;
                if (ExpressionNumericConverter.TryGetConstantIntValue(greaterThan.Right, out var constValue) &&
                    constValue == 0 &&
                    IsIndexOfCall(greaterThan.Left, c.SemanticModel))
                {
                    c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, Location.Create(greaterThan.SyntaxTree,
                                                                                         TextSpan.FromBounds(greaterThan.OperatorToken.SpanStart, greaterThan.Right.Span.End))));
                }
            },
                SyntaxKind.GreaterThanExpression);
        }
Exemplo n.º 2
0
 private static bool CheckExpression(ExpressionSyntax constant, ExpressionSyntax modulus, SemanticModel semanticModel,
                                     out int constantValue)
 {
     return(ExpressionNumericConverter.TryGetConstantIntValue(constant, out constantValue) &&
            constantValue != 0 &&
            ExpressionIsModulus(modulus) &&
            !ExpressionIsNonNegative(modulus, semanticModel));
 }
 private static void CheckCountOne(ExpressionSyntax one, ExpressionSyntax count, SyntaxNodeAnalysisContext context)
 {
     if (ExpressionNumericConverter.TryGetConstantIntValue(one, out var value) &&
         value == 1 &&
         TryGetCountCall(count, context.SemanticModel, out var reportLocation, out var typeArgument))
     {
         context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, reportLocation, typeArgument));
     }
 }
        private static void CheckCountZero(ExpressionSyntax zero, ExpressionSyntax count, SyntaxNodeAnalysisContext context)
        {
            Location reportLocation;
            string   typeArgument;
            int      value;

            if (ExpressionNumericConverter.TryGetConstantIntValue(zero, out value) &&
                value == 0 &&
                TryGetCountCall(count, context.SemanticModel, out reportLocation, out typeArgument))
            {
                context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, reportLocation, typeArgument));
            }
        }
Exemplo n.º 5
0
        private static void CheckCountOne(ExpressionSyntax one, ExpressionSyntax count, SyntaxNodeAnalysisContext c)
        {
            Location reportLocation;
            string   typeArgument;
            int      value;

            if (ExpressionNumericConverter.TryGetConstantIntValue(one, out value) &&
                value == 1 &&
                TryGetCountCall(count, c.SemanticModel, out reportLocation, out typeArgument))
            {
                c.ReportDiagnostic(Diagnostic.Create(Rule, reportLocation, typeArgument));
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// We try to retrieve the integer value of an expression. If the expression is an integer literal, we return its value, otherwise if
        /// the expression is an identifier, we attempt to retrieve the integer value the variable was initialized with if it exists.
        /// </summary>
        /// <param name="variableNameToIntegerValue">A dictionary mapping variable names to the integer value they were initialized with if it exists</param>
        /// <param name="expression">The expression for which we want to retrieve the integer value</param>
        /// <param name="intValue">The output parameter that will hold the integer value if it is found</param>
        /// <returns>true if an integer value was found for the expression, false otherwise</returns>
        private static bool GetIntValue(IDictionary <string, int> variableNameToIntegerValue, ExpressionSyntax expression, out int intValue)
        {
            if (ExpressionNumericConverter.TryGetConstantIntValue(expression, out intValue) ||
                (
                    expression is SimpleNameSyntax simpleName &&
                    variableNameToIntegerValue.TryGetValue(simpleName.Identifier.ValueText, out intValue)
                ))
            {
                return(true);
            }

            intValue = default(int);
            return(false);
        }
Exemplo n.º 7
0
        private static void CheckAssignment(SyntaxNodeAnalysisContext context, int constValueToLookFor)
        {
            var assignment = (AssignmentExpressionSyntax)context.Node;

            if (ExpressionNumericConverter.TryGetConstantIntValue(assignment.Right, out var constValue) &&
                constValue == constValueToLookFor)
            {
                var location = assignment.Parent is StatementSyntax
                    ? assignment.Parent.GetLocation()
                    : GetReportLocation(assignment.OperatorToken.Span, assignment.Right.Span, assignment.SyntaxTree);

                context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, location));
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Retrieves the mapping of variable names to their integer value from the variable declaration part of a for loop.
        /// This will find the mapping for such cases:
        /// <code>
        /// for (var i = 0;;) {}
        /// </code>
        /// </summary>
        private static IDictionary <string, int> GetVariableDeclarationMapping(VariableDeclarationSyntax variableDeclarationSyntax)
        {
            var loopInitializerValues = new Dictionary <string, int>();

            if (variableDeclarationSyntax != null)
            {
                foreach (var variableDeclaration in variableDeclarationSyntax.Variables)
                {
                    if (variableDeclaration.Initializer is EqualsValueClauseSyntax initializer &&
                        ExpressionNumericConverter.TryGetConstantIntValue(initializer.Value, out var intValue))
                    {
                        loopInitializerValues.Add(variableDeclaration.Identifier.ValueText, intValue);
                    }
                }
            }
            return(loopInitializerValues);
        }
Exemplo n.º 9
0
        /// <summary>
        /// Retrieves the mapping of variable names to their integer value from the initializer part of a for loop.
        /// This will find the mapping for such cases:
        /// <code>
        /// int i;
        /// for (i = 0;;) {}
        /// </code>
        /// </summary>
        private static IDictionary <string, int> GetLoopInitializerMapping(IEnumerable <ExpressionSyntax> initializers)
        {
            var loopInitializerValues = new Dictionary <string, int>();

            if (initializers != null)
            {
                foreach (var initializer in initializers)
                {
                    if (initializer.IsKind(SyntaxKind.SimpleAssignmentExpression) &&
                        initializer is AssignmentExpressionSyntax assignment &&
                        assignment.Left is SimpleNameSyntax simpleName &&
                        ExpressionNumericConverter.TryGetConstantIntValue(assignment.Right, out var intValue))
                    {
                        loopInitializerValues.Add(simpleName.Identifier.ValueText, intValue);
                    }
                }
            }
            return(loopInitializerValues);
        }
Exemplo n.º 10
0
        private static void CheckBinary(SyntaxNodeAnalysisContext context, int constValueToLookFor)
        {
            var binary = (BinaryExpressionSyntax)context.Node;

            if (ExpressionNumericConverter.TryGetConstantIntValue(binary.Left, out var constValue) &&
                constValue == constValueToLookFor)
            {
                var location = GetReportLocation(binary.Left.Span, binary.OperatorToken.Span, binary.SyntaxTree);
                context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, location, ImmutableDictionary <string, string> .Empty.Add(IsReportingOnLeftKey, true.ToString())));
                return;
            }

            if (ExpressionNumericConverter.TryGetConstantIntValue(binary.Right, out constValue) &&
                constValue == constValueToLookFor)
            {
                var location = GetReportLocation(binary.OperatorToken.Span, binary.Right.Span, binary.SyntaxTree);
                context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, location, ImmutableDictionary <string, string> .Empty.Add(IsReportingOnLeftKey, false.ToString())));
            }
        }
Exemplo n.º 11
0
        public override void Initialize(AnalysisContext context)
        {
            context.RegisterSyntaxNodeActionInNonGenerated(
                c =>
            {
                var expression = (BinaryExpressionSyntax)c.Node;
                int value;
                if (expression.IsKind(SyntaxKind.LeftShiftExpression) &&
                    ExpressionNumericConverter.TryGetConstantIntValue(expression.Right, out value) &&
                    value == 1)
                {
                    return;
                }

                if (EquivalenceChecker.AreEquivalent(expression.Left, expression.Right))
                {
                    c.ReportDiagnostic(Diagnostic.Create(Rule, c.Node.GetLocation(), expression.OperatorToken));
                }
            },
                SyntaxElementsToCheck);
        }
        private static bool CheckValueTypeDefaultValueInitializer(EqualsValueClauseSyntax initializer, ITypeSymbol type)
        {
            if (!type.IsValueType)
            {
                return(false);
            }

            switch (type.SpecialType)
            {
            case SpecialType.System_Boolean:
                return(EquivalenceChecker.AreEquivalent(initializer.Value, SyntaxHelper.FalseLiteralExpression));

            case SpecialType.System_Decimal:
            case SpecialType.System_Double:
            case SpecialType.System_Single:
            {
                double constantValue;
                return(ExpressionNumericConverter.TryGetConstantDoubleValue(initializer.Value, out constantValue) &&
                       Math.Abs(constantValue - default(double)) < double.Epsilon);
            }

            case SpecialType.System_Char:
            case SpecialType.System_Byte:
            case SpecialType.System_Int16:
            case SpecialType.System_Int32:
            case SpecialType.System_Int64:
            case SpecialType.System_SByte:
            case SpecialType.System_UInt16:
            case SpecialType.System_UInt32:
            case SpecialType.System_UInt64:
            {
                int constantValue;
                return(ExpressionNumericConverter.TryGetConstantIntValue(initializer.Value, out constantValue) &&
                       constantValue == default(int));
            }

            default:
                return(false);
            }
        }
        private static bool CheckValueTypeDefaultValueInitializer(VariableDeclaratorSyntax variable, IFieldSymbol variableSymbol)
        {
            if (!variableSymbol.Type.IsValueType)
            {
                return(false);
            }

            switch (variableSymbol.Type.SpecialType)
            {
            case SpecialType.System_Boolean:
                return(EquivalenceChecker.AreEquivalent(variable.Initializer.Value, FalseExpression));

            case SpecialType.System_Decimal:
            case SpecialType.System_Double:
            case SpecialType.System_Single:
            {
                double constantValue;
                return(ExpressionNumericConverter.TryGetConstantDoubleValue(variable.Initializer.Value, out constantValue) &&
                       Math.Abs(constantValue - default(double)) < double.Epsilon);
            }

            case SpecialType.System_Char:
            case SpecialType.System_Byte:
            case SpecialType.System_Int16:
            case SpecialType.System_Int32:
            case SpecialType.System_Int64:
            case SpecialType.System_SByte:
            case SpecialType.System_UInt16:
            case SpecialType.System_UInt32:
            case SpecialType.System_UInt64:
            {
                int constantValue;
                return(ExpressionNumericConverter.TryGetConstantIntValue(variable.Initializer.Value, out constantValue) &&
                       constantValue == default(int));
            }

            default:
                return(false);
            }
        }