private static void ConstructorCallsCheck(SyntaxNodeAnalysisContext context)
        {
            var node = context.Node as ConstructorDeclarationSyntax;

            if (node != null)
            {
                var usingStatements = AnalyzerHelpers.FindChildrenOfType <UsingStatementSyntax>(node.Body);
                DetectScopeCalls(context, usingStatements);

                foreach (var invocation in AnalyzerHelpers.FindChildrenOfType <InvocationExpressionSyntax>(node))
                {
                    if (IsLazyInstantiated(invocation))
                    {
                        continue;
                    }

                    var memberAccess = AnalyzerHelpers.FindChildrenOfType <MemberAccessExpressionSyntax>(invocation).FirstOrDefault();
                    if (memberAccess != null)
                    {
                        var symbol = context.SemanticModel.GetSymbolInfo(memberAccess);
                        if (symbol.Symbol != null && symbol.Symbol.Locations.Length > 0)
                        {
                            var location = symbol.Symbol.Locations[0];
                            if (location.SourceTree != null)
                            {
                                var root = location.SourceTree.GetRoot();
                                foreach (var method in AnalyzerHelpers.FindChildrenOfType <MethodDeclarationSyntax>(root))
                                {
                                    if (method.Identifier.ValueText == symbol.Symbol.Name)
                                    {
                                        usingStatements = AnalyzerHelpers.FindChildrenOfType <UsingStatementSyntax>(method);
                                        DetectScopeCalls(context, usingStatements, memberAccess);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        private static void DetectScopeCalls(SyntaxNodeAnalysisContext context, IEnumerable <UsingStatementSyntax> nodes, SyntaxNode parent = null)
        {
            foreach (var node in nodes)
            {
                if (node.Declaration != null && node.Declaration.ToString().Contains("DalScope.Begin"))
                {
                    var scopeVariableName = node.Declaration.Variables[0].Identifier.ValueText;

                    foreach (var invocation in AnalyzerHelpers.FindChildrenOfType <InvocationExpressionSyntax>(node))
                    {
                        var str = invocation.ToString();
                        if (str.Contains(scopeVariableName) && (str.Contains(".Fetch") || str.Contains(".TryFetch") || str.Contains(".Exists")))
                        {
                            var location = parent != null?parent.GetLocation() : node.GetLocation();

                            var diagnostic = Diagnostic.Create(Rule, location);
                            context.ReportDiagnostic(diagnostic);
                        }
                    }
                }
            }
        }
Exemple #3
0
        private static void CommitCheck(SyntaxNodeAnalysisContext context)
        {
            var node = context.Node as UsingStatementSyntax;

            if (node != null)
            {
                if (node.Declaration != null && node.Declaration.ToString().Contains("DalScope.Begin"))
                {
                    var scopeVariableName = node.Declaration.Variables[0].Identifier.ValueText;

                    var block = node.Statement as BlockSyntax;
                    if (block != null)
                    {
                        bool isUpdateBlock  = false;
                        bool hasScopeCommit = false;
                        foreach (var invocation in AnalyzerHelpers.FindChildrenOfType <InvocationExpressionSyntax>(block))
                        {
                            var str = invocation.ToString();
                            if (str.Contains(".Update(") || str.Contains(".Insert(") || str.Contains(".Delete("))
                            {
                                isUpdateBlock = true;
                            }

                            if (str.Contains(scopeVariableName) && str.Contains(".Commit("))
                            {
                                hasScopeCommit = true;
                            }
                        }

                        if (isUpdateBlock && !hasScopeCommit)
                        {
                            var diagnostic = Diagnostic.Create(Rule, node.GetLocation());
                            context.ReportDiagnostic(diagnostic);
                        }
                    }
                }
            }
        }