예제 #1
0
        public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
        {
            if (node.FirstAncestorOrSelf <PropertyDeclarationSyntax>() != null &&
                node.FirstAncestorOrSelf <PropertyDeclarationSyntax>().Identifier.Text == "SelectorExpression")
            {
                var customExpressions = node.Initializer.Expressions
                                        .Where(p => this._finder.IsNodeWithinCustomCode(p))
                                        .Select(p => p.WithoutTrivia())
                                        .ToList();

                var nodeTokenList = SyntaxFactory.NodeOrTokenList();

                foreach (var existingExp in customExpressions)
                {
                    nodeTokenList = nodeTokenList.Add(existingExp);
                    nodeTokenList = nodeTokenList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).AppendNewLine());
                }

                var res = node.WithInitializer(node.Initializer
                                               .WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken))
                                               .WithExpressions(SyntaxFactory.SeparatedList <ExpressionSyntax>(nodeTokenList)));

                return(res);
            }

            return(node);
        }
        private static ISymbol GetAssignedVariableSymbol(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel)
        {
            var variable = objectCreation.FirstAncestorOrSelf <AssignmentExpressionSyntax>()?.Left;

            if (variable != null)
            {
                return(semanticModel.GetSymbolInfo(variable).Symbol);
            }

            var identifier = objectCreation.FirstAncestorOrSelf <VariableDeclaratorSyntax>();

            return(identifier != null
                ? semanticModel.GetDeclaredSymbol(identifier)
                : null);
        }
        private bool IsLaterAssignedWithAllowedValue(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel)
        {
            var statement = objectCreation.FirstAncestorOrSelf <StatementSyntax>();

            if (statement == null)
            {
                return(false);
            }

            var variableSymbol = GetAssignedVariableSymbol(objectCreation, semanticModel);

            var nextStatements  = GetNextStatements(statement);
            var innerStatements = GetInnerStatements(statement);

            return(variableSymbol != null &&
                   nextStatements.Union(innerStatements)
                   .OfType <ExpressionStatementSyntax>()
                   .Select(x => x.Expression)
                   .OfType <AssignmentExpressionSyntax>()
                   .Any(TrackedPropertySetWithAllowedValue));

            bool TrackedPropertySetWithAllowedValue(AssignmentExpressionSyntax assignment) =>
            variableSymbol.Equals(GetAssignedVariableSymbol(assignment, semanticModel)) &&
            IsTrackedPropertyName(assignment.Left) &&
            IsAllowedValue(assignment.Right, semanticModel);
        }
예제 #4
0
        internal static bool TryGetDependencyProperty(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, CancellationToken cancellationToken, out IFieldSymbol dependencyProperty)
        {
            dependencyProperty = null;
            var declarator = objectCreation.FirstAncestorOrSelf <VariableDeclaratorSyntax>();

            if (declarator == null)
            {
                return(false);
            }

            dependencyProperty = semanticModel.GetDeclaredSymbolSafe(declarator, cancellationToken) as IFieldSymbol;
            return(dependencyProperty != null);
        }
        private static List <Param> GetSqlParams(
            SyntaxNodeAnalysisContext context,
            ObjectCreationExpressionSyntax node,
            IEnumerable <SyntaxNode> siblings)
        {
            var parameters = new List <Param>();

            var variableDeclarator = node.FirstAncestorOrSelf <VariableDeclaratorSyntax>();

            if (variableDeclarator is null)
            {
                return(parameters);
            }

            var variableSymbol = context.SemanticModel.GetDeclaredSymbol(variableDeclarator);

            foreach (var sibling in siblings)
            {
                // command.Parameters.AddWithValue
                if (sibling is InvocationExpressionSyntax invocation &&
                    invocation.Expression is MemberAccessExpressionSyntax addWithValue &&
                    addWithValue.Name.ToString() == "AddWithValue" &&
                    addWithValue.Expression is MemberAccessExpressionSyntax paramsExpr &&
                    paramsExpr.Name.ToString() == "Parameters" &&
                    paramsExpr.Expression is IdentifierNameSyntax command &&
                    context.SemanticModel.GetSymbolInfo(command).Symbol == variableSymbol)
                {
                    var paramNameExpression = invocation.ArgumentList.Arguments[0].Expression;
                    var valueExpression     = invocation.ArgumentList.Arguments[1].Expression;
                    var paramName           = paramNameExpression.GetConstantValue(context.Compilation);

                    if (paramName.StartsWith("@") && paramName.Length >= 2)
                    {
                        paramName = paramName.Substring(1);
                    }

                    parameters.Add(new Param
                    {
                        Name     = paramName,
                        Location = invocation.GetLocation(),
                        Value    = valueExpression.GetDummyValue(context.SemanticModel)
                    });
                }
            }

            return(parameters);
        }
예제 #6
0
        public static bool IsPartOfStaticMemberDeclaration(this ObjectCreationExpressionSyntax objectCreationExprSyntax)
        {
            var memberForObjectCreationExpr = objectCreationExprSyntax.FirstAncestorOrSelf <MemberDeclarationSyntax>();

            switch (memberForObjectCreationExpr.Kind())
            {
            case SyntaxKind.ConstructorDeclaration:
                var constructorDeclaration = (ConstructorDeclarationSyntax)memberForObjectCreationExpr;
                return(constructorDeclaration.Modifiers.Any(SyntaxKind.StaticKeyword));

            case SyntaxKind.FieldDeclaration:
                var fieldDeclaration = (FieldDeclarationSyntax)memberForObjectCreationExpr;
                return(fieldDeclaration.Modifiers.Any(SyntaxKind.StaticKeyword));
            }

            return(false);
        }
예제 #7
0
        internal static bool TryGetDependencyProperty(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty fieldOrProperty)
        {
            fieldOrProperty = default;
            var invocation = objectCreation.FirstAncestorOrSelf <InvocationExpressionSyntax>();

            if (invocation == null)
            {
                return(false);
            }

            if (DependencyProperty.TryGetRegisterCall(invocation, semanticModel, cancellationToken, out _) ||
                DependencyProperty.TryGetRegisterReadOnlyCall(invocation, semanticModel, cancellationToken, out _) ||
                DependencyProperty.TryGetRegisterAttachedCall(invocation, semanticModel, cancellationToken, out _) ||
                DependencyProperty.TryGetRegisterAttachedReadOnlyCall(invocation, semanticModel, cancellationToken, out _))
            {
                if (objectCreation.TryFirstAncestor <FieldDeclarationSyntax>(out var fieldDeclaration) &&
                    semanticModel.TryGetSymbol(fieldDeclaration, cancellationToken, out var field))
                {
                    return(BackingFieldOrProperty.TryCreateForDependencyProperty(field, out fieldOrProperty));
                }

                if (objectCreation.TryFirstAncestor <PropertyDeclarationSyntax>(out var propertyDeclaration) &&
                    semanticModel.TryGetSymbol(propertyDeclaration, cancellationToken, out var property))
                {
                    return(BackingFieldOrProperty.TryCreateForDependencyProperty(property, out fieldOrProperty));
                }

                return(false);
            }

            if (invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
                (DependencyProperty.TryGetAddOwnerCall(invocation, semanticModel, cancellationToken, out _) ||
                 DependencyProperty.TryGetOverrideMetadataCall(invocation, semanticModel, cancellationToken, out _)) &&
                semanticModel.TryGetSymbol(memberAccess.Expression, cancellationToken, out ISymbol? candidate))
            {
                return(BackingFieldOrProperty.TryCreateForDependencyProperty(candidate, out fieldOrProperty));
            }

            return(false);
        }
예제 #8
0
            public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
            {
                if (((CSharpCompilation)semanticModel.Compilation).LanguageVersion.MapSpecifiedToEffectiveVersion() != LanguageVersion.CSharp9)
                {
                    return(base.VisitObjectCreationExpression(node));
                }

                if (node.NewKeyword == null ||
                    node.Parent.IsKind(SyntaxKind.LocalDeclarationStatement) ||
                    node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression) ||
                    node.Parent.IsKind(SyntaxKind.UsingStatement))
                {
                    return(base.VisitObjectCreationExpression(node));
                }

                //if (node.Parent.IsKind(SyntaxKind.LocalDeclarationStatement))
                //    return base.VisitObjectCreationExpression(node);

                //if (node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression))
                //    return base.VisitObjectCreationExpression(node);

                //if (node.Parent.IsKind(SyntaxKind.UsingStatement))
                //    return base.VisitObjectCreationExpression(node);

                var newNode = node.WithType(SyntaxFactory.ParseTypeName(""))
                              .WithNewKeyword(node.NewKeyword.WithoutWhiteSpaceTrivia())
                              .WithArgumentList(node.ArgumentList ?? SyntaxFactory.ParseArgumentList("()"));

                var nodeTypeinfo = semanticModel.GetTypeInfo(node);
                var parentSymbol = semanticModel.GetSymbolInfo(node.Parent).Symbol;

                if (parentSymbol?.Kind == SymbolKind.Method &&
                    (parentSymbol as IMethodSymbol)?.MethodKind == MethodKind.AnonymousFunction)
                {
                    return(base.VisitObjectCreationExpression(node));
                }

                if (node.Parent.IsKind(SyntaxKind.ReturnStatement))
                {
                    var methodDeclaration   = node.FirstAncestorOrSelf <MethodDeclarationSyntax>();
                    var propertyDeclaration = node.FirstAncestorOrSelf <PropertyDeclarationSyntax>();

                    if (methodDeclaration != null)
                    {
                        if (methodDeclaration.ReturnType.ToString() != nodeTypeinfo.Type.Name)
                        {
                            return(base.VisitObjectCreationExpression(node));
                        }

                        var symbol = semanticModel.GetDeclaredSymbol(methodDeclaration);

                        if (symbol.ReturnType.TypeKind != TypeKind.Class)
                        {
                            return(base.VisitObjectCreationExpression(node));
                        }
                    }
                    else if (propertyDeclaration != null)
                    {
                        var symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration);

                        if (symbol.GetMethod.ReturnType.TypeKind != TypeKind.Class)
                        {
                            return(base.VisitObjectCreationExpression(node));
                        }
                    }
                }
                else if (node.Parent.IsKind(SyntaxKind.Argument))
                {
                    var methodInvocation = node.FirstAncestorOrSelf <InvocationExpressionSyntax>();

                    if (methodInvocation != null)
                    {
                        var methodSymbol = semanticModel.GetSymbolInfo(methodInvocation).Symbol;

                        var countofMethod = methodSymbol?.ContainingType?.GetMembers()
                                            .Count(x => x.Name ==
                                                   (methodInvocation.Expression.IsKind(SyntaxKind.SimpleMemberAccessExpression) ?
                                                    methodInvocation.GetRightSideNameSyntax().ToString() :
                                                    methodInvocation.Expression.ToString()));

                        if (countofMethod > 1)
                        {
                            return(base.VisitObjectCreationExpression(node));
                        }

                        var indexOfMethod = node.FirstAncestorOrSelf <ArgumentListSyntax>().Arguments
                                            .IndexOf(node.AncestorsAndSelf().FirstOrDefault(x => x.Parent.IsKind(SyntaxKind.ArgumentList)) as ArgumentSyntax);

                        if ((methodSymbol as IMethodSymbol)?.OriginalDefinition.Parameters[indexOfMethod].IsParams == true)
                        {
                            return(base.VisitObjectCreationExpression(node));
                        }

                        if ((methodSymbol as IMethodSymbol)?.OriginalDefinition.IsGenericMethod == true &&
                            (methodInvocation.Expression.IsKind(SyntaxKind.SimpleMemberAccessExpression) ?
                             !methodInvocation.GetRightSideNameSyntax().IsKind(SyntaxKind.GenericName) :
                             !methodInvocation.Expression.IsKind(SyntaxKind.GenericName)))
                        {
                            return(base.VisitObjectCreationExpression(node));
                        }
                    }
                    else
                    {
                        return(base.VisitObjectCreationExpression(node));
                    }
                }
                else if (node.Parent.IsKind(SyntaxKind.ArrayInitializerExpression))
                {
                    if (node.Parent.Parent.IsKind(SyntaxKind.ImplicitArrayCreationExpression))
                    {
                        return(base.VisitObjectCreationExpression(node));
                    }
                }

                if (nodeTypeinfo.ConvertedType.ToString() == nodeTypeinfo.Type.ToString())
                {
                    if (isReportOnlyMode)
                    {
                        var lineSpan = node.GetFileLinePosSpan();

                        AddReport(new ChangesReport(node)
                        {
                            LineNumber = lineSpan.StartLinePosition.Line,
                            Column     = lineSpan.StartLinePosition.Character,
                            Message    = "Object Creation new Syntax in c# v9",
                            Generator  = nameof(CSharpSyntaxUpgrade)
                        });
                    }

                    return(newNode);
                }

                return(base.VisitObjectCreationExpression(node));
            }
예제 #9
0
 internal static bool TryGetRegisteredName(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, CancellationToken cancellationToken, out string registeredName)
 {
     registeredName = null;
     return(TryGetConstructor(objectCreation, semanticModel, cancellationToken, out _) &&
            DependencyProperty.TryGetRegisteredName(objectCreation?.FirstAncestorOrSelf <InvocationExpressionSyntax>(), semanticModel, cancellationToken, out registeredName));
 }