Пример #1
0
        public static bool IsAccessOnNewlyCreatedObject(KnownSymbols knownSymbols,
                                                        SemanticModel semanticModel,
                                                        SyntaxNode node, RecursiveState recursiveState1)
        {
            bool IsOnNewlyCreatedObject(ExpressionSyntax exp)
            {
                if (exp is MemberAccessExpressionSyntax memberAccess1)
                {
                    return(IsOnNewlyCreatedObject(memberAccess1.Expression));
                }
                if (exp is ElementAccessExpressionSyntax elementAccess1)
                {
                    return(IsOnNewlyCreatedObject(elementAccess1.Expression));
                }
                return(Utils.IsNewlyCreatedObject(semanticModel, exp, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState1));
            }

            if (node.Parent is MemberAccessExpressionSyntax memberAccess)
            {
                return(IsOnNewlyCreatedObject(memberAccess));
            }

            if (node is ElementAccessExpressionSyntax elementAccess)
            {
                return(IsOnNewlyCreatedObject(elementAccess));
            }

            return(false);
        }
Пример #2
0
        ChangeAcceptedPurityTypeBasedOnWhetherExpressionRepresentsANewObjectOrParameterBasedExpression(
            PurityType currentAcceptedPurityType,
            ExpressionSyntax node,
            KnownSymbols knownSymbols,
            SemanticModel semanticModel,
            RecursiveState recursiveState)
        {
            if (Utils.IsNewlyCreatedObject(semanticModel, node, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState))
            {
                return(PurityType.PureExceptLocally);
            }
            else if (ImpuritiesFinder.IsParameter(semanticModel, node))
            {
                return(PurityType.PureExceptReadLocally);
            }

            return(currentAcceptedPurityType);
        }
Пример #3
0
        public static IEnumerable <ExpressionSyntax> GetNonNewObjectReturnsForPropertyGet(
            PropertyDeclarationSyntax propertyDeclaration,
            SemanticModel semanticModel,
            KnownSymbols knownSymbols,
            RecursiveState recursiveState1)
        {
            var propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration);

            if (propertySymbol.GetMethod == null)
            {
                yield break;
            }

            if (!propertySymbol.ReturnsByRef && IsCompleteValueType(propertySymbol.Type))
            {
                yield break;
            }

            List <ExpressionSyntax> returnExpressions;

            if (propertyDeclaration.AccessorList != null)
            {
                var getAccessor =
                    propertyDeclaration.AccessorList.Accessors.FirstOrNoValue(x =>
                                                                              x.Keyword.Kind() == SyntaxKind.GetKeyword);

                if (getAccessor.HasNoValue)
                {
                    yield break;
                }

                var getAccessorValue = getAccessor.GetValue();

                returnExpressions =
                    getAccessorValue.ExpressionBody != null
                        ? new List <ExpressionSyntax>()
                {
                    getAccessorValue.ExpressionBody.Expression
                }
                        : getAccessor.GetValue()
                .DescendantNodes()
                .OfType <ReturnStatementSyntax>()
                .Select(x => x.Expression)
                .ToList();
            }
            else if (propertyDeclaration.ExpressionBody != null)
            {
                returnExpressions = new List <ExpressionSyntax>()
                {
                    propertyDeclaration.ExpressionBody.Expression
                };
            }
            else
            {
                yield break;
            }

            foreach (var expression in returnExpressions)
            {
                if (!Utils.IsNewlyCreatedObject(semanticModel, expression, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState1))
                {
                    yield return(expression);
                }
            }
        }
Пример #4
0
        public static IEnumerable <ExpressionSyntax> GetNonNewObjectReturnsForMethod(
            BaseMethodDeclarationSyntax methodDeclaration,
            SemanticModel semanticModel,
            KnownSymbols knownSymbols, RecursiveState recursiveState1)
        {
            var methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration);

            if (!methodSymbol.ReturnsByRef && IsCompleteValueType(methodSymbol.ReturnType))
            {
                yield break;
            }

            var returnExpressions =
                methodDeclaration.Body != null
                    ? methodDeclaration.Body
                .DescendantNodes()
                .OfType <ReturnStatementSyntax>()
                .Select(x => x.Expression)
                .ToArray()
                    : new[] { methodDeclaration.ExpressionBody.Expression };

            foreach (var expression in returnExpressions)
            {
                if (!Utils.IsNewlyCreatedObject(semanticModel, expression, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState1))
                {
                    yield return(expression);
                }
            }
        }