C# MethodDeclarationSyntax.DescendantNodes方法代码示例

        private int ProcessMethodCallsInMethod(MethodDeclarationSyntax node, int n)
        {
            int sum = 0; 
            var hashcode = node.Identifier.ToString() + node.ParameterList.ToString();
            if (!AnalyzedMethods.ContainsKey(hashcode))
            {
                var newMethods = new List<MethodDeclarationSyntax>();
                AnalyzedMethods.Add(hashcode, sum);
                try
                {
                    foreach (var methodCall in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
                    {
                        var semanticModelForThisMethodCall = Document.Project.Solution.GetDocument(methodCall.SyntaxTree).GetSemanticModelAsync().Result;

                        var methodCallSymbol = (IMethodSymbol)semanticModelForThisMethodCall.GetSymbolInfo(methodCall).Symbol;

                        if (methodCallSymbol != null)
                        {

                            if (methodCallSymbol.IsDispatcherBeginInvoke() || methodCallSymbol.IsDispatcherInvoke())
                                AnalyzedMethods[hashcode]++;

                            var methodDeclarationNode = methodCallSymbol.FindMethodDeclarationNode();
                            if (methodDeclarationNode != null)
                                newMethods.Add(methodDeclarationNode);
                        }
                    }

                    if (n < 3)
                    {
                        foreach (var newMethod in newMethods)
                            AnalyzedMethods[hashcode] += ProcessMethodCallsInMethod(newMethod, n + 1);
                    }
                }
                catch (Exception ex)
                {

                    Logs.Console.Warn("Caught exception while processing method call node: {0} @ {1}", node, ex.Message);

                    if (!(ex is InvalidProjectFileException ||
                          ex is FormatException ||
                          ex is ArgumentException ||
                          ex is PathTooLongException))
                        throw;
                }
               
            }
            else
                return AnalyzedMethods[hashcode];

            return sum;
        }

        public TaskDeclaration(string path, MethodDeclarationSyntax declaration, bool step)
        {
            Debug.Assert(path != null);
            Debug.Assert(declaration != null);

            this.path = path;
            this.declaration = declaration;
            this.step = step;

            var documentation = declaration
                .DescendantNodes(descendIntoTrivia: true)
                .OfType<DocumentationCommentTriviaSyntax>()
                .FirstOrDefault();

            if (documentation != null)
                comments = documentation.Content.ToString()
                            .Replace("///", "").Trim(' ').TrimEnd('\n').TrimEnd('\r');
        }

        /// <summary>
        /// Computes the summary for the given method.
        /// </summary>
        /// <param name="method">Method</param>
        /// <param name="machine">Machine</param>
        /// <param name="state">State</param>
        private void ComputeSummaryForMethod(MethodDeclarationSyntax method,
            ClassDeclarationSyntax machine, ClassDeclarationSyntax state)
        {
            List<InvocationExpressionSyntax> givesUpSources = new List<InvocationExpressionSyntax>();
            foreach (var call in method.DescendantNodes().OfType<InvocationExpressionSyntax>())
            {
                var model = this.AnalysisContext.Compilation.GetSemanticModel(call.SyntaxTree);

                var callSymbol = model.GetSymbolInfo(call).Symbol;
                if (callSymbol == null)
                {
                    continue;
                }

                var definition = SymbolFinder.FindSourceDefinitionAsync(callSymbol,
                    this.AnalysisContext.Solution).Result;
                if (definition == null)
                {
                    continue;
                }

                var callee = this.AnalysisContext.GetCallee(call);
                var calleeMethod = definition.DeclaringSyntaxReferences.First().GetSyntax()
                    as BaseMethodDeclarationSyntax;

                if (this.AnalysisContext.IsSourceOfGivingUpOwnership(call, model, callee) ||
                    this.AnalysisContext.Summaries.ContainsKey(calleeMethod))
                {
                    givesUpSources.Add(call);
                }
                else if (machine.ChildNodes().OfType<BaseMethodDeclarationSyntax>().Contains(calleeMethod) &&
                    !this.AnalysisContext.Summaries.ContainsKey(calleeMethod) &&
                    !calleeMethod.Modifiers.Any(SyntaxKind.AbstractKeyword))
                {
                    return;
                }
            }

            MethodSummary summary = MethodSummary.Factory.Summarize(this.AnalysisContext, method, machine, state);
            foreach (var givesUpNode in summary.GivesUpNodes)
            {
                this.TryComputeGivesUpSetForSendControlFlowGraphNode(givesUpNode, summary);
                this.TryComputeGivesUpSetForCreateControlFlowGraphNode(givesUpNode, summary);
                this.TryComputeGivesUpSetForGenericControlFlowGraphNode(givesUpNode, summary);
            }
        }

        private SyntaxNode rewriteFunction(MethodDeclarationSyntax node, bool asPublic)
        {
            //since no return type has been spacified we need to know if it returns something
            bool            returns   = node.DescendantNodes().OfType<ReturnStatementSyntax>().Any();
            TypeSyntax      rtype     = returns ? SyntaxFactory.IdentifierName("object") : SyntaxFactory.IdentifierName("void");

            List<SyntaxToken> modifiers = new List<SyntaxToken>();
            bool found = false;
            foreach (var mod in node.Modifiers)
            {
                switch(mod.CSharpKind())
                {
                    case SyntaxKind.PublicKeyword:
                    case SyntaxKind.PrivateKeyword:
                    case SyntaxKind.ProtectedKeyword:
                    case SyntaxKind.InternalKeyword:
                    {
                        found = true;
                        break;
                    }
                }

                modifiers.Add(mod);
            }

            if (!found)
            {
                if (asPublic)
                    modifiers.AddRange(Compiler.Public);
                else
                    modifiers.AddRange(Compiler.Private);
            }

            SyntaxNode result = SyntaxFactory.MethodDeclaration(rtype, node.Identifier)
                                    .WithModifiers(SyntaxFactory.TokenList(modifiers))
                                    .WithParameterList(rewriteParamList(node.ParameterList))
                                    .WithBody(rewriteBody(node.Body))
                                    .WithAdditionalAnnotations( new SyntaxAnnotation("ExcessFunction"));

            return returns? ctx_.AddLinker(result, (ctx, linkNode, newNode, model) =>
            {
                MethodDeclarationSyntax mthod = (MethodDeclarationSyntax)linkNode;
                ControlFlowAnalysis     cfa   = model.AnalyzeControlFlow(mthod.Body);

                ITypeSymbol rt     = null;
                foreach (var rs in cfa.ReturnStatements)
                {
                    ReturnStatementSyntax rss  = (ReturnStatementSyntax)rs;
                    ITypeSymbol           type = model.GetSpeculativeTypeInfo(rss.Expression.SpanStart, rss.Expression, SpeculativeBindingOption.BindAsExpression).Type;

                    if (type == null)
                        continue;

                    if (type.TypeKind == TypeKind.Error)
                        return newNode;

                    if (rt == null)
                        rt = type;
                    else if (rt != type)
                        return newNode;
                }

                if (rt == null)
                    return newNode;

                MethodDeclarationSyntax res = (MethodDeclarationSyntax)newNode;
                return res.WithReturnType(SyntaxFactory.ParseTypeName(rt.Name));
            }) : result;
        }

		private static string CreateSafeLocalVariableName(MethodDeclarationSyntax methodNode, IMethodSymbol methodSymbol)
		{
			var localDeclarations = methodNode.DescendantNodes(_ => true).OfType<VariableDeclaratorSyntax>();
			var returnValueName = $"{methodSymbol.Name.Substring(0, 1).ToLower()}{methodSymbol.Name.Substring(1)}Result";
			var returnValueSafeName = returnValueName;
			var returnValueCount = 0;

			// Create a "safe" local variable name.
			while (localDeclarations.Any(_ => _.Identifier.Text == returnValueSafeName))
			{
				returnValueSafeName = $"{returnValueName}{returnValueCount}";
				returnValueCount++;
			}

			return returnValueSafeName;
		}

		private static bool IsUnnecessaryAsyncAwait(MethodDeclarationSyntax node)
		{
            if(node.AttributeLists.Any(a => a.ToFullString().Contains("TestMethod")))
            {
                return false;
            }

			int numAwaits = Regex.Matches(node.Body.ToString(), "await").Count;
			int numReturnAwaits = Regex.Matches(node.Body.ToString(), "return await").Count;

			if (!node.ReturnType.ToString().Equals("void") &&
				!node.DescendantNodes().OfType<StatementSyntax>().Where(a => a.ToString().Contains("await")).Any(a => a.Ancestors().OfType<TryStatementSyntax>().Any()))
			{
				if (numAwaits == numReturnAwaits)
					return true;
				else if (numAwaits == 1 && node.Body.Statements.Count > 0 && node.Body.Statements.Last().ToString().StartsWith("await"))
					return true;
			}
			return false;
		}

		private bool IsUnnecessarilyCaptureContext(MethodDeclarationSyntax node, int n)
		{
			if (CheckUIElementAccess(node))
				return false;
			else
			{
				bool result = true;
				{
					var newMethods = new List<MethodDeclarationSyntax>();
					try
					{
						var semanticModel = SourceFile.Project.Solution.GetDocument(node.SyntaxTree).GetSemanticModelAsync().Result;
						if (semanticModel != null)
						{
							foreach (var methodCall in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
							{
								var methodCallSymbol = (IMethodSymbol)semanticModel.GetSymbolInfo(methodCall).Symbol;

								if (methodCallSymbol != null)
								{
									var methodDeclarationNode = methodCallSymbol.FindMethodDeclarationNode();
									if (methodDeclarationNode != null && n < 10)
										newMethods.Add(methodDeclarationNode);
								}
							}
						}
						foreach (var newMethod in newMethods)
							result = result && IsUnnecessarilyCaptureContext(newMethod, n + 1);
					}
					catch (Exception ex)
					{

					}
				}
				return result;
			}
		}

		private bool IsThereLongRunning(MethodDeclarationSyntax node, out string replacement)
		{
            replacement = string.Empty;
            foreach (var blocking in node.DescendantNodes().OfType<MemberAccessExpressionSyntax>().Where(a => BlockingMethodCalls.Any(b => b.Equals(a.Name.ToString()))))
            {
                replacement = "Blocking Method Calls";
                return true;
            }

			foreach (var methodCall in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
			{
				var methodCallSymbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(methodCall).Symbol;
				if (methodCallSymbol != null)
				{
					replacement = DetectSynchronousUsages((IMethodSymbol)methodCallSymbol.OriginalDefinition, SemanticModel);

					if (!string.IsNullOrEmpty(replacement))
					{
                        if (!methodCallSymbol.Name.ToString().Equals("Invoke"))
                        {
                            return true;
                        }
					}
				}
			}

			return false;
		}

        private void ProcessMethodCallsInMethod(MethodDeclarationSyntax node, int n, string topAncestor)
        {
            var hashcode = node.Identifier.ToString() + node.ParameterList.ToString();

            bool asyncFlag = false;
            if (node.HasAsyncModifier())
                asyncFlag = true;

            if (!AnalyzedMethods.Contains(hashcode))
            {
                AnalyzedMethods.Add(hashcode);

                var newMethods = new List<MethodDeclarationSyntax>();
                try
                {
                    var semanticModel = Document.Project.Solution.GetDocument(node.SyntaxTree).GetSemanticModelAsync().Result;

                    foreach (var blocking in node.DescendantNodes().OfType<MemberAccessExpressionSyntax>().Where(a => BlockingMethodCalls.Any(b => b.Equals(a.Name.ToString()))))
                    {
                        Logs.TempLog2.Info("BLOCKING {0} {1} {2}\r\n{3} \r\n{4}\r\n{5}\r\n--------------------------", asyncFlag, n, blocking, Document.FilePath, topAncestor, node);
                    }

                    foreach (var blocking in node.DescendantNodes().OfType<MemberAccessExpressionSyntax>().Where(a => a.Name.ToString().Equals("Result")))
                    {
                        var s = semanticModel.GetSymbolInfo(blocking).Symbol;
                        if (s != null && s.ToString().Contains("System.Threading.Tasks"))
                            Logs.TempLog2.Info("BLOCKING {0} {1} {2}\r\n{3} \r\n{4}\r\n{5}\r\n--------------------------", asyncFlag, n, blocking, Document.FilePath, topAncestor, node);
                    }

                    foreach (var methodCall in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
                    {
                        var methodCallSymbol = (IMethodSymbol)semanticModel.GetSymbolInfo(methodCall).Symbol;

                        if (methodCallSymbol != null)
                        {
                            var replacement = ((IMethodSymbol)methodCallSymbol.OriginalDefinition).DetectSynchronousUsages(SemanticModel);

                            if (replacement != "None")
                            {
                                if (!methodCallSymbol.Name.ToString().Equals("Invoke"))
                                    Logs.TempLog2.Info("LONGRUNNING {0} {1} {2} {3}\r\n{4} {5}\r\n{6}\r\n--------------------------", asyncFlag, n, methodCallSymbol, Document.FilePath, replacement, topAncestor, node);
                                Logs.TempLog3.Info("{0} {1}", methodCallSymbol.ContainingType, methodCallSymbol, replacement);
                            }

                            var methodDeclarationNode = methodCallSymbol.FindMethodDeclarationNode();
                            if (methodDeclarationNode != null)
                                newMethods.Add(methodDeclarationNode);
                        }
                    }

                    foreach (var newMethod in newMethods)
                        ProcessMethodCallsInMethod(newMethod, n + 1, topAncestor);
                }
                catch (Exception ex)
                {
                    Logs.Console.Warn("Caught exception while processing method call node: {0} @ {1}", node, ex.Message);

                    if (!(
                          ex is FormatException ||
                          ex is ArgumentException ||
                          ex is PathTooLongException))
                        throw;
                }
            }
        }

        private static IEnumerable<string> DeclaredIdentifiers(MethodDeclarationSyntax syntax)
        {
            var methodParameterNames = syntax.ParameterList.Parameters
                .Select(p => p.Identifier.ValueText);

            var methodLocalVars = syntax
                .DescendantNodes()
                .OfType<LocalDeclarationStatementSyntax>()
                .SelectMany(d => d.Declaration.Variables)
                .Select(v => v.Identifier.ValueText);

            var classFieldIds = syntax.ContainingClass()
                .DescendantNodes()
                .OfType<FieldDeclarationSyntax>()
                .SelectMany(f => f.Declaration.Variables)
                .Select(v => v.Identifier.ValueText);

            var classPropertyIds = syntax.ContainingClass()
                .DescendantNodes()
                .OfType<PropertyDeclarationSyntax>()
                .Select(p => p.Identifier.ValueText);

            var classMethodIds = syntax.ContainingClass()
                .DescendantNodes()
                .OfType<MethodDeclarationSyntax>()
                .Select(m => m.Identifier.ValueText);

            var classDelegateIds = syntax.ContainingClass()
                .DescendantNodes()
                .OfType<DelegateDeclarationSyntax>()
                .Select(d => d.Identifier.ValueText);

            return methodParameterNames
                .Concat(methodLocalVars)
                .Concat(classFieldIds)
                .Concat(classPropertyIds)
                .Concat(classMethodIds)
                .Concat(classDelegateIds);
        }

        private void ExtractMethodTests(TestFixtureDetails testFixture, MethodDeclarationSyntax methodNode, ISemanticModel semanticModel)
        {
            var allMethodTestCases = new List<TestCase>();

            foreach (AttributeSyntax attribute in methodNode.DescendantNodes().OfType<AttributeSyntax>())
            {
                var methodTestCases=ExtractMethodsFromAttributes(testFixture, semanticModel, attribute);
                allMethodTestCases.AddRange(methodTestCases);
            }

            if (allMethodTestCases.Count > 0)
            {
                int maxPars = allMethodTestCases.Max(x => x.Arguments.Length);
                testFixture.Cases.AddRange(allMethodTestCases.Where(x => x.Arguments.Length == maxPars));
            }
        }