Пример #1
0
#pragma warning disable AV1561 // Signature contains more than 3 parameters
            public ArgumentsInfo([NotNull] IOperation leftArgument, [NotNull] IOperation rightArgument,
                                 NullCheckMethod nullCheckMethod, NullCheckOperand nullCheckOperand)
            {
                LeftArgument     = leftArgument;
                RightArgument    = rightArgument;
                NullCheckMethod  = nullCheckMethod;
                NullCheckOperand = nullCheckOperand;
            }
Пример #2
0
        public NullCheckScanResult([NotNull] IOperation target, NullCheckMethod method, NullCheckOperand operand)
        {
            Guard.NotNull(target, nameof(target));

            Target  = target;
            Method  = method;
            Operand = operand;
        }
        public static NullCheckOperand CombineWith(this NullCheckOperand first, NullCheckOperand second)
        {
            if (first == NullCheckOperand.IsNull)
            {
                return(second == NullCheckOperand.IsNull ? NullCheckOperand.IsNull : NullCheckOperand.IsNotNull);
            }

            return(second == NullCheckOperand.IsNull ? NullCheckOperand.IsNotNull : NullCheckOperand.IsNull);
        }
Пример #4
0
        public NullCheckScanResult?ScanPropertyReference([NotNull] IPropertyReferenceOperation propertyReference)
        {
            Guard.NotNull(propertyReference, nameof(propertyReference));

            if (propertyReference.Property.OriginalDefinition.Equals(knownSymbols.NullableHasValueProperty) &&
                IsNullableValueType(propertyReference.Instance))
            {
                NullCheckOperand nullCheckOperand = GetParentNullCheckOperand(propertyReference);

                return(new NullCheckScanResult(propertyReference.Instance, NullCheckMethod.NullableHasValueMethod,
                                               nullCheckOperand.Toggle()));
            }

            return(null);
        }
Пример #5
0
        private NullCheckScanResult?AnalyzeSingleArgumentInvocation([NotNull] IInvocationOperation invocation)
        {
            if (invocation.Instance != null)
            {
                bool isNullableEquals = invocation.TargetMethod.OriginalDefinition.Equals(knownSymbols.NullableEqualsMethod);
                if (isNullableEquals)
                {
                    NullCheckOperand nullCheckOperand = GetParentNullCheckOperand(invocation);

                    return(AnalyzeArguments(new ArgumentsInfo(invocation.Instance, invocation.Arguments[0].Value,
                                                              NullCheckMethod.NullableEqualsMethod, nullCheckOperand)));
                }
            }

            return(null);
        }
Пример #6
0
        public NullCheckScanResult?ScanIsPattern([NotNull] IIsPatternOperation isPattern)
        {
            Guard.NotNull(isPattern, nameof(isPattern));

            if (isPattern.Pattern is IConstantPatternOperation constantPattern)
            {
                if (IsConstantNullOrDefault(constantPattern.Value) && IsNullableValueType(isPattern.Value))
                {
                    NullCheckOperand nullCheckOperand = GetParentNullCheckOperand(isPattern);

                    return(new NullCheckScanResult(isPattern.Value, NullCheckMethod.IsPattern, nullCheckOperand));
                }
            }

            return(null);
        }
Пример #7
0
        private NullCheckScanResult?AnalyzeDoubleArgumentInvocation([NotNull] IInvocationOperation invocation)
        {
            NullCheckMethod?nullCheckMethod = TryGetNullCheckForDoubleArgumentInvocation(invocation);

            if (nullCheckMethod != null)
            {
                IArgumentOperation leftArgument  = invocation.Arguments[0];
                IArgumentOperation rightArgument = invocation.Arguments[1];

                NullCheckOperand nullCheckOperand = GetParentNullCheckOperand(invocation);

                return(AnalyzeArguments(new ArgumentsInfo(leftArgument.Value, rightArgument.Value, nullCheckMethod.Value,
                                                          nullCheckOperand)));
            }

            return(null);
        }
Пример #8
0
        public NullCheckScanResult?ScanBinaryOperator([NotNull] IBinaryOperation binaryOperator)
        {
            Guard.NotNull(binaryOperator, nameof(binaryOperator));

            NullCheckOperand?operatorNullCheckOperand = TryGetBinaryOperatorNullCheckOperand(binaryOperator);

            if (operatorNullCheckOperand == null)
            {
                return(null);
            }

            NullCheckOperand parentNullCheckOperand   = GetParentNullCheckOperand(binaryOperator);
            NullCheckOperand nullCheckOperandCombined = parentNullCheckOperand.CombineWith(operatorNullCheckOperand.Value);

            return(AnalyzeArguments(new ArgumentsInfo(binaryOperator.LeftOperand, binaryOperator.RightOperand,
                                                      NullCheckMethod.EqualityOperator, nullCheckOperandCombined)));
        }
 public static NullCheckOperand Toggle(this NullCheckOperand operand)
 {
     return(operand == NullCheckOperand.IsNull ? NullCheckOperand.IsNotNull : NullCheckOperand.IsNull);
 }