public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
        {
            if (!node.HasAsyncModifier())
            {
                base.VisitMethodDeclaration(node);
                return;
            }

            if (node.ToString().Contains("await"))
            {
                Result.asyncAwaitResults.NumAsyncMethods++;

                Logs.TempLog.Info(@"{0}{1}**********************************************", Document.FilePath, node.ToLog());

                if (!node.ReturnType.ToString().Equals("void"))
                {
                    Result.asyncAwaitResults.NumAsyncTaskMethods++;
                }

                if (IsFireForget(node))
                    Result.StoreDetectedAsyncMisuse(1, Document, node);

                if (IsUnnecessaryAsyncAwait(node))
                    Result.StoreDetectedAsyncMisuse(2, Document, node);

                if (IsThereLongRunning(node))
                    Result.StoreDetectedAsyncMisuse(3, Document, node);

                if (IsUnnecessarilyCaptureContext(node, 0))
                    Result.StoreDetectedAsyncMisuse(4, Document, node);


                //var symbol = SemanticModel.GetDeclaredSymbol(node);
                //if (symbol != null)
                //{

                //    foreach (var refs in SymbolFinder.FindReferencesAsync(symbol, Document.Project.Solution).Result)
                //    {
                //        foreach (var loc in refs.Locations)
                //        {
                //            var caller = loc.Document.GetTextAsync().Result.Lines.ElementAt(loc.Location.GetLineSpan().StartLinePosition.Line).ToString();
                //            if (caller.Contains(".Result") || caller.Contains(".Wait"))
                //                Logs.TempLog5.Info("{0}{1}{2}{3}************************************",
                //                    System.Environment.NewLine + "Blocking Caller: '" + caller.Trim() + "' from this file: " + loc.Document.FilePath + System.Environment.NewLine,
                //                    System.Environment.NewLine + "Async method Callee: " + System.Environment.NewLine,
                //                    node.ToLog(),
                //                    "From this file: " + Document.FilePath + System.Environment.NewLine + System.Environment.NewLine);
                //        }
                //    }
                //}
            }
            else
                Logs.AsyncMisuse.Info(@"{0} - {1}{2}**********************************************", Document.FilePath, "No Await", node.ToLog());

            base.VisitMethodDeclaration(node);
        }
        public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
        {
            if (node.HasAsyncModifier() && node.ToString().Contains("await"))
            {
                if(Result.CurrentAnalyzedProjectType == Enums.ProjectType.WP7)
                    Result.asyncUsageResults_WP7.NumAsyncAwaitMethods++;
                else
                    Result.asyncUsageResults_WP8.NumAsyncAwaitMethods++;
            }
                    

            base.VisitMethodDeclaration(node);
        }
        public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
        {

            //if (node.HasAsyncModifier() && !node.ToString().Contains("await"))
            //{
            //    Logs.TempLog5.Info("NotHavingAwait {0}\r\n{1}\r\n------------------------------", Document.FilePath, node);
            //}
            if (node.HasAsyncModifier() && node.ToString().Contains("await"))
            {
                if (Result.CurrentAnalyzedProjectType == Enums.ProjectType.WP7)
                    Result.asyncAwaitResults.NumAsyncAwaitMethods_WP7++;
                else
                    Result.asyncAwaitResults.NumAsyncAwaitMethods_WP8++;

                if (node.ReturnType.ToString().Equals("void"))
                {
                    if (node.HasEventArgsParameter())
                        Result.asyncAwaitResults.NumAsyncVoidEventHandlerMethods++;
                    else
                        Result.asyncAwaitResults.NumAsyncVoidNonEventHandlerMethods++;
                }
                else
                    Result.asyncAwaitResults.NumAsyncTaskMethods++;




                if (IsFireForget(node))
                    Result.WriteDetectedMisuseAsyncUsageToTable(1, Document, node);

                if (IsUnnecessaryAsyncAwait(node))
                    Result.WriteDetectedMisuseAsyncUsageToTable(2, Document, node);

                if(IsThereLongRunning(node))
                    Result.WriteDetectedMisuseAsyncUsageToTable(3, Document, node);

                if (IsUnnecessarilyCaptureContext(node, 0))
                    Result.WriteDetectedMisuseAsyncUsageToTable(4,Document,node);

                    //Logs.TempLog.Info("ConfigureAwaitUse {0}\r\n{1}\r\n------------------------------",Document.FilePath,node);

                //var endTime = DateTime.UtcNow;
                //Logs.TempLog5.Info(endTime.Subtract(startTime).Milliseconds);




                //if (node.Body.ToString().Contains("ConfigureAwait"))
                //{

                //    Result.asyncAwaitResults.NumAsyncMethodsHavingConfigureAwait++;
                //    Logs.TempLog5.Info("ConfigureAwait {0}\r\n{1}\r\n------------------------------", Document.FilePath, node);
                //}



                //foreach (var loop in node.DescendantNodes().Where(a => a is ForEachStatementSyntax || a is ForStatementSyntax || a is WhileStatementSyntax))
                //{
                //    foreach (var tap in loop.DescendantNodes().OfType<InvocationExpressionSyntax>())
                //    {
                //        MethodSymbol sym = (MethodSymbol)SemanticModel.GetSymbolInfo(tap).Symbol;
                //        if (sym != null && sym.IsTAPMethod())
                //            Logs.TempLog2.Info("ExpensiveAwaits {0} {1}\r\n{2}\r\n-----------------------", sym, Document.FilePath, node);
                //    }
                //}

                //var symbol = SemanticModel.GetDeclaredSymbol(node);
                //bool isThereAnyCaller = false;
                //if (symbol != null)
                //{
                //    foreach (var refs in SymbolFinder.FindReferencesAsync(symbol, Document.Project.Solution).Result)
                //    {
                //        foreach (var locs in refs.Locations)
                //        {
                //            isThereAnyCaller = true;
                //            var caller = locs.Document.GetTextAsync().Result.Lines.ElementAt(locs.Location.GetLineSpan(false).StartLinePosition.Line).ToString();
                //            if (caller.Contains(".Result") || caller.Contains(".Wait"))
                //                Logs.TempLog5.Info("BlockingCaller {0}\r\n{1}\r\n{2}\r\n-----------------------", Document.FilePath, node, caller);

                //        }
                //    }
                //}
            }

            //if (node.HasEventArgsParameter())
            //{
            //    var arg = node.ParameterList.Parameters.Where(param => param.Type.ToString().EndsWith("EventArgs")).First();

            //    var type = SemanticModel.GetTypeInfo(arg.Type).Type;

            //    if (type.ToString().StartsWith("System.Windows"))
            //    {
            //        ProcessMethodCallsInMethod(node, 0, node.Identifier.ToString() + node.ParameterList.ToString());
            //    }
            //}
            base.VisitMethodDeclaration(node);
        }