Example #1
0
        private void GetDatabaseAccessingSelectStatementsInQuerySyntax(SyntaxNode rootOfDocument, SemanticModel semanticModel)
        {
            foreach (var invocationExpSyntax in rootOfDocument.DescendantNodes().OfType <InvocationExpressionSyntax>())
            {
                //If Query is defined within the same line
                var queryExpSyntax = invocationExpSyntax.DescendantNodes().OfType <QueryExpressionSyntax>().FirstOrDefault();
                if (queryExpSyntax != null)
                {
                    if (SyntaxNodeIsDatabaseQuery(queryExpSyntax, semanticModel))
                    {
                        AddDatabaseAccessingCall(invocationExpSyntax, semanticModel);
                    }
                }
                //else if invocation is done on an already defined query variable
                else
                {
                    MemberAccessExpressionSyntax memberAccessExpSyntax = invocationExpSyntax.DescendantNodes().OfType <MemberAccessExpressionSyntax>().FirstOrDefault();

                    if (memberAccessExpSyntax != null)
                    {
                        var queryVariable = (from identifier in memberAccessExpSyntax.DescendantNodes().OfType <IdentifierNameSyntax>()
                                             from queryVar in DatabaseQueryVariables
                                             where identifier.Identifier.ToString() == queryVar.VariableName
                                             select queryVar).FirstOrDefault();

                        if (queryVariable != null)
                        {
                            AddDatabaseAccessingCall(invocationExpSyntax, semanticModel, queryVariable);
                        }
                    }
                }
            }
        }
Example #2
0
        private static void AnalyzeSmae(SyntaxNodeAnalysisContext context)
        {
            SyntaxNode node = context.Node;

            if (!node.IsKind(SyntaxKind.SimpleMemberAccessExpression))
            {
                return;
            }

            MemberAccessExpressionSyntax mae = (MemberAccessExpressionSyntax)node;

            //account.Attributes.Add("Name", "test");
            IdentifierNameSyntax identifier = mae.DescendantNodes().OfType <IdentifierNameSyntax>().FirstOrDefault();

            if (identifier == null)
            {
                return;
            }

            ITypeSymbol type = context.SemanticModel.GetTypeInfo(identifier).Type;

            if (type == null)
            {
                return;
            }

            //If type is not Microsoft.Xrm.Sdk.Entity - exit
            if (type.ToString() != "Microsoft.Xrm.Sdk.Entity")
            {
                return;
            }

            //If argument does not contain an uppercase letter - exit
            var arguments = mae.Parent.DescendantNodes().OfType <ArgumentSyntax>();

            if (!arguments.Any())
            {
                return;
            }

            if (!arguments.First().Expression.GetFirstToken().ValueText.ToCharArray().Any(char.IsUpper))
            {
                return;
            }

            var diagnostic = Diagnostic.Create(Rule, arguments.First().GetLocation(), arguments.First().Expression.GetFirstToken().ValueText);

            context.ReportDiagnostic(diagnostic);
        }
        public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
        {
            var identifierNames = node.DescendantNodes()
                                  .OfType <SimpleNameSyntax>()
                                  .ToList();

            if (identifierNames.Count < 2)
            {
                return;
            }

            if (identifierNames[0]
                .Identifier.Text != _variableName)
            {
                return;
            }

            MethodCalls.Add(identifierNames[1].Identifier.Text);
        }
Example #4
0
 private static bool IsChainedMemberAccesses(MemberAccessExpressionSyntax memberAccess)
 => memberAccess.DescendantNodes().OfType <MemberAccessExpressionSyntax>().Any();