private async Task<Document> ReturnVoidAsync(Document document, MethodDeclarationSyntax method, CancellationToken cancellationToken) { var newStatements = new List<StatementSyntax>(); foreach (var s in method.Body.Statements) { if (s is ReturnStatementSyntax) { continue; } else newStatements.Add(s); } var newMethodDeclaration = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void").WithLeadingTrivia(method.ReturnType.GetLeadingTrivia()).WithTrailingTrivia(method.ReturnType.GetTrailingTrivia()), method.Identifier) .AddModifiers(method.Modifiers.ToArray()) .WithLeadingTrivia(method.GetLeadingTrivia()) .WithBody(SyntaxFactory.Block(newStatements)) ; var root = await document.GetSyntaxRootAsync(); var newRoot = root.ReplaceNode(method, newMethodDeclaration); return document.WithSyntaxRoot(newRoot); }
private async Task<Document> RepairXmlCommentAsync(Document document, MethodDeclarationSyntax methodSyntax, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var methodSymbol = model.GetDeclaredSymbol(methodSyntax); var xml = methodSymbol.GetDocumentationCommentXml(); var documentTrivia = methodSyntax.GetLeadingTrivia().Where(n => n.Kind() == SyntaxKind.SingleLineDocumentationCommentTrivia).Last(); var documentText = documentTrivia.ToFullString().TrimEnd(); var invalidXml = Regex.Replace(documentText, @"^\s*///", "", RegexOptions.Multiline); var newXml = RpairXml(invalidXml); var newDocumentCommentText = Regex.Replace(newXml, @"^", "///", RegexOptions.Multiline) + "\r\n"; var newDocumentTrivia = SyntaxFactory.ParseLeadingTrivia(newDocumentCommentText)[0]; var newRoot = root.ReplaceTrivia(documentTrivia, newDocumentTrivia.WithAdditionalAnnotations(Formatter.Annotation)); var newDocument = document.WithSyntaxRoot(newRoot); return newDocument; }
public override SyntaxNode FixParameters(MethodDeclarationSyntax method, SyntaxNode root) { var documentationNode = method.GetLeadingTrivia().Select(x => x.GetStructure()).OfType<DocumentationCommentTriviaSyntax>().First(); var allNodesToRemove = GetAllNodesToRemove(GetMethodParametersWithDocParameters(method, documentationNode), documentationNode); var newDocumentationNode = documentationNode.RemoveNodes(allNodesToRemove, SyntaxRemoveOptions.KeepNoTrivia); return root.ReplaceNode(documentationNode, newDocumentationNode); }
private async Task<Document> EnableQueryAsync(Document document, MethodDeclarationSyntax node, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(); var newMethod = node.WithoutLeadingTrivia().WithAttributeLists(node.AttributeLists.Add(SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList<AttributeSyntax>( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("EnableQuery")))))).WithLeadingTrivia(node.GetLeadingTrivia()); var newRoot = root.ReplaceNode(node, newMethod); var newDocument = document.WithSyntaxRoot(newRoot); return newDocument; }
/// <summary> /// Détermine si le inheritDoc du symbole méthode est présent et correct. /// </summary> /// <param name="racine">Le nœud racine de l'arbre syntaxtique courant.</param> /// <param name="modèleSémantique">Le modèle sémantique lié.</param> /// <param name="méthode">La méthode concernée.</param> /// <returns>La ligne inheritDoc correcte dans le cas où l'actuelle est manquante/incorrecte, sinon null.</returns> public static string InheritDocEstCorrect(SyntaxNode racine, SemanticModel modèleSémantique, MethodDeclarationSyntax méthode) { var classe = méthode?.Parent as ClassDeclarationSyntax; // Si on est bien dans une méthode de classe. if (méthode != null && classe != null) { // On récupère la version sémantique de la méthode pour identifier ses paramètres. var méthodeSémantique = modèleSémantique.GetDeclaredSymbol(méthode); // On liste toutes les méthodes des interfaces de la classe puis on cherche l'unique méthode avec la même signature. var méthodeCorrespondantes = modèleSémantique.GetDeclaredSymbol(classe).Interfaces .SelectMany(contrat => contrat.GetMembers()) .Where(méthodeInterface => méthodeInterface.Name == méthode.Identifier.Text && ((méthodeInterface as IMethodSymbol)?.Parameters.SequenceEqual(méthodeSémantique.Parameters, (p1, p2) => p1.Name == p2.Name) ?? false)); var méthodeCorrespondante = (méthodeCorrespondantes.Count() == 1 ? méthodeCorrespondantes.Single() : null) as IMethodSymbol; // S'il y a bien une méthode correspondante, on continue. if (méthodeCorrespondante != null) { // On récupère le nombre de méthode du même nom dans l'interface pour savoir s'il faut spécifier les paramètres ou non. var nombreMéthodesSurchargées = (méthodeCorrespondante.ContainingSymbol as INamedTypeSymbol).GetMembers() .Count(méthodeInterface => méthodeInterface.Name == méthode.Identifier.Text); #pragma warning disable SA1013, SA1513 // On génère la ligne de documentation. var inheritDoc = $@"/// <inheritdoc cref=""{ RécupérerNomType(méthode, méthodeCorrespondante, modèleSémantique) }.{ RécupérerNomMéthode(méthode, méthodeCorrespondante) + RécupérerParamètres(méthode, méthodeCorrespondante, modèleSémantique, nombreMéthodesSurchargées) }"" />"; #pragma warning restore SA1013, SA1513 // On récupère la documentation actuelle de la classe. var documentationActuelle = méthode.GetLeadingTrivia().ToString().Replace("\n", string.Empty).Replace("\r", string.Empty).Replace(" ", string.Empty); // On la compare avec la ligne existante de façon bien crade, parce qu'en vrai elle n'est pas générée correctement. // Désolé. J'ai vraiment essayé de faire proprement mais la génération propre de commentaires XML est odieuse. // Si la ligne est différente et ne contient pas le mot "summary", on retourne la ligne de commentaire attendue. if (!inheritDoc.Replace("\n", string.Empty).Replace("\r", string.Empty).Replace(" ", string.Empty) .Equals(documentationActuelle) && !documentationActuelle.Contains("summary")) return inheritDoc; } } // Sinon on renvoie null, pour affirmer au diagnostic que tout va bien. return null; }
static bool DoesContainingMethodDeclareExceptionType(MethodDeclarationSyntax containingMethod, string expectedExceptionTypeToDeclare) { var documentationTrivias = containingMethod.GetLeadingTrivia().Where(x => x.CSharpKind() == SyntaxKind.SingleLineDocumentationCommentTrivia); foreach (var documentationTrivia in documentationTrivias) { var documentationTriviaStructure = (DocumentationCommentTriviaSyntax)documentationTrivia.GetStructure(); var xmlElements = documentationTriviaStructure.Content.OfType<XmlElementSyntax>(); var exceptionDeclarations = xmlElements.Where(x => x.StartTag.Name.ToFullString().ToLowerInvariant() == "exception"); return exceptionDeclarations.Any(x => x.StartTag.Attributes.Any(y => y.CSharpKind() == SyntaxKind.XmlCrefAttribute && ((XmlCrefAttributeSyntax)y).Cref.ToString() == expectedExceptionTypeToDeclare)); } return false; }
private async Task<Document> ReplacePropertyModifierAsync(Document document, MethodDeclarationSyntax method, SyntaxKind methodModifier, CancellationToken cancellationToken) { var previousWhiteSpacesToken = SyntaxFactory.Token(method.GetLeadingTrivia(), SyntaxKind.StringLiteralToken, SyntaxTriviaList.Empty); var newProperty = method.WithModifiers(SyntaxTokenList.Create(previousWhiteSpacesToken) .Add(SyntaxFactory.Token(methodModifier)) .Add(_whitespaceToken)); if (method.Modifiers.Any(m => m.Kind() == SyntaxKind.VirtualKeyword)) { newProperty = newProperty.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword), _whitespaceToken); } return await ReplacePropertyInDocumentAsync(document, method, newProperty, cancellationToken); }
public override SyntaxNode FixParameters(MethodDeclarationSyntax method, SyntaxNode root) { var documentationNode = method.GetLeadingTrivia().Select(x => x.GetStructure()).OfType<DocumentationCommentTriviaSyntax>().First(); var newDocumentationNode = documentationNode; var methodParameterWithDocParameter = GetMethodParametersWithDocParameters(method, documentationNode); var xmlText = documentationNode.Content.OfType<XmlTextSyntax>().Skip(1).First(); var nodesToAdd = methodParameterWithDocParameter.Where(p => p.Item2 == null) .SelectMany(x => CreateParamenterXmlDocumentation(xmlText, x.Item1.Identifier.ValueText, method.Identifier.ValueText)) .ToList(); var newFormation = newDocumentationNode.Content.OfType<XmlElementSyntax>().ToList(); var node = newFormation.LastOrDefault(xEle => xEle.StartTag.Name.LocalName.ValueText == "param") ?? newFormation.LastOrDefault(xEle => xEle.StartTag.Name.LocalName.ValueText == "summary"); var nodeInList = documentationNode.Content.OfType<XmlTextSyntax>().FirstOrDefault(x => x.FullSpan.Start == node.FullSpan.End); newDocumentationNode = newDocumentationNode.InsertNodesAfter(node, nodesToAdd.Cast<SyntaxNode>()); return root.ReplaceNode(documentationNode, newDocumentationNode); }
private static async Task<Document> ReplaceWithExpressionBodiedMember(Document document, MethodDeclarationSyntax declaration, CancellationToken cancellationToken) { SyntaxTriviaList leadingTrivia; var expression = GetExpressionAndLeadingTrivia(declaration.Body, out leadingTrivia); var declarationTrivia = declaration.GetLeadingTrivia(); declarationTrivia = declarationTrivia.AddRange(leadingTrivia); var newDeclaration = declaration .WithLeadingTrivia(declarationTrivia) .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(expression)) .WithBody(null) .WithSemicolonToken(GetSemicolon(declaration.Body)) .WithAdditionalAnnotations(Formatter.Annotation); var root = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = root.ReplaceNode(declaration, newDeclaration); return document.WithSyntaxRoot(newRoot); }
public override SyntaxNode FixParameters(MethodDeclarationSyntax method, SyntaxNode root) { var documentationNode = method.GetLeadingTrivia().Select(x => x.GetStructure()).OfType<DocumentationCommentTriviaSyntax>().First(); var newDocumentationNode = documentationNode; var methodParameterWithDocParameter = GetMethodParametersWithDocParameters(method, documentationNode); var newFormation = newDocumentationNode.Content.OfType<XmlElementSyntax>(); var nodesToAdd = methodParameterWithDocParameter.Where(p => p.Item2 == null) .Select(x => CreateParamenterXmlDocumentation(x.Item1.Identifier.ValueText, method.Identifier.ValueText)) .Union(newFormation) .OrderByDescending(xEle => xEle.StartTag.Name.LocalName.ValueText == "summary") .ThenByDescending(xEle => xEle.StartTag.Name.LocalName.ValueText == "param") .SelectMany(EnvolveXmlDocSyntaxWithNewLine) .ToList(); newDocumentationNode = newDocumentationNode.WithContent(SyntaxFactory.List(nodesToAdd)); return root.ReplaceNode(documentationNode, newDocumentationNode); }
/// <summary> /// Add documentation for the property. /// </summary> /// <param name="context">the code fix context.</param> /// <param name="root">the root syntax node.</param> /// <param name="methodDeclaration">the property declaration containing invalid documentation.</param> /// <param name="documentComment">the existing comment.</param> /// <returns>the correct code.</returns> private Task<Document> AddDocumentationAsync( CodeFixContext context, SyntaxNode root, MethodDeclarationSyntax methodDeclaration, DocumentationCommentTriviaSyntax documentComment) { var summary = this._commentNodeFactory.GetExistingSummaryCommentText(documentComment) ?? this._commentNodeFactory.CreateCommentSummaryText(methodDeclaration); var @class = methodDeclaration.Parent as ClassDeclarationSyntax; var first = @class?.DescendantNodes().FirstOrDefault() == methodDeclaration; var parameters = this._commentNodeFactory.CreateParameters(methodDeclaration, documentComment); var typeParameters = this._commentNodeFactory.CreateTypeParameters(methodDeclaration, documentComment); var @return = this._commentNodeFactory.CreateReturnValueDocumentation(methodDeclaration, documentComment); var returns = @return == null ? new XmlElementSyntax[] { } : new[] { @return }; var summaryPlusParameters = new XmlNodeSyntax[] { summary } .Concat(parameters) .Concat(returns) .Concat(typeParameters) .ToArray(); var comment = this._commentNodeFactory .CreateDocumentComment(summaryPlusParameters) .AddLeadingEndOfLineTriviaFrom(methodDeclaration.GetLeadingTrivia()); var trivia = SyntaxFactory.Trivia(comment); var methodTrivia = first ? methodDeclaration.WithLeadingTrivia(trivia) : methodDeclaration.WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, trivia); var result = documentComment != null ? root.ReplaceNode(documentComment, comment.AdjustDocumentationCommentNewLineTrivia()) : root.ReplaceNode(methodDeclaration, methodTrivia); var newDocument = context.Document.WithSyntaxRoot(result); return Task.FromResult(newDocument); }
public static MethodDeclarationSyntax Trivia(this MethodDeclarationSyntax node, MethodDeclarationSyntax that) { return node.WithLeadingTrivia(that.GetLeadingTrivia()).WithTrailingTrivia(that.GetTrailingTrivia()); }
//private object TransverseClassTypes(object classType) //{ // object retObj; // if (classType is ClassDeclarationSyntax) // { // retObj = new Class(); // classType = classType as ClassDeclarationSyntax; // } // else if (classType is StructDeclarationSyntax) // { // retObj = new Struct(); // classType = classType as StructDeclarationSyntax; // } // //Class retObj = new Class(); // //Name // (retObj is Class ? retObj as Class : retObj as Struct).Name = (classType is ClassDeclarationSyntax ? (ClassDeclarationSyntax)classType : (StructDeclarationSyntax)classType).Identifier.ValueText; // //encapsulation // foreach (SyntaxToken st in classType.Modifiers) // { // string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText); // retObj.Encapsulation.Add((Encapsulation)System.Enum.Parse(typeof(Encapsulation), modifier)); // } // var enums = from aEnu in classType.ChildNodes().OfType<EnumDeclarationSyntax>() select aEnu; // foreach (EnumDeclarationSyntax eds in enums) // { // retObj.Enums.Add(TraverseEnums(eds)); // } // var structs = from aStruct in classType.ChildNodes().OfType<StructDeclarationSyntax>() select aStruct; // foreach (StructDeclarationSyntax sds in structs) // { // retObj.Structs.Add(TransverseStructs(sds)); // } // var methods = from aMethod in classType.ChildNodes().OfType<MethodDeclarationSyntax>() select aMethod; // foreach (MethodDeclarationSyntax mds in methods) // { // retObj.Methods.Add(TransverseMethods(mds)); // } // var fields = from aField in classType.ChildNodes().OfType<FieldDeclarationSyntax>() select aField; // foreach (FieldDeclarationSyntax fds in fields) // { // retObj.Attributes.Add(TransverseVariables(fds)); // } // //var properties = from aProperty in classType.ChildNodes().OfType<PropertyDeclarationSyntax>() select aProperty; // //foreach (PropertyDeclarationSyntax pds in properties) // //{ // // //traverse attributes // //} // var constructors = from aConstructor in classType.ChildNodes().OfType<ConstructorDeclarationSyntax>() select aConstructor; // foreach (ConstructorDeclarationSyntax cods in constructors) // { // retObj.Constructors.Add(TransverseConstructors(cods)); // } // var destructors = from aDestructor in classType.ChildNodes().OfType<DestructorDeclarationSyntax>() select aDestructor; // foreach (DestructorDeclarationSyntax dds in destructors) // { // retObj.Destructors.Add(TransverseDestructors(dds)); // } // var classes = from aClass in classType.ChildNodes().OfType<ClassDeclarationSyntax>() select aClass; // foreach (ClassDeclarationSyntax classType2 in classes) // { // retObj.Classes.Add(TraverseClass(classType2)); // } // return retObj; //} private Method TransverseMethods(MethodDeclarationSyntax mds) { Method retMethod = new Method(); //public int DecisionsCount { get; } //public int ExitPoints { get; set; } //public bool IsFriend { get; } //public bool IsPolymophic { get; } //public bool IsPublic { get; } //public bool IsStatic { get; } //public List<Preprocessor> Preprocessors { get; set; } retMethod.Name = mds.Identifier.ValueText; if (mds.HasLeadingTrivia) { SetOuterComments(retMethod, mds.GetLeadingTrivia().ToFullString()); } if (mds.HasTrailingTrivia) { SetInnerComments(retMethod, mds.GetTrailingTrivia().ToFullString()); } foreach (SyntaxToken st in mds.Modifiers) { string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText); Encapsulation encap; Qualifiers qual; if (System.Enum.TryParse<Encapsulation>(modifier, out encap)) { retMethod.Encapsulation.Add(encap); } else if (System.Enum.TryParse<Qualifiers>(modifier, out qual)) { retMethod.Qualifiers.Add(qual); } } TypeSyntax ts = mds.ReturnType; Model.Type retType = new Model.Type(); retType.Name = ts.ToString(); retType.IsKnownType = SyntaxFacts.IsKeywordKind(ts.CSharpKind()); retType.IsNotUserDefined = SyntaxFacts.IsKeywordKind(ts.CSharpKind()); //TODO //rettype.generictype retMethod.ReturnType = retType; ParameterListSyntax pls = mds.ParameterList; foreach (ParameterSyntax ps in pls.Parameters) { retMethod.Parameters.Add(TraverseParamaters(ps)); } BlockSyntax bs = mds.Body; if (bs != null) { var labelStatements = from aLabelStatement in bs.ChildNodes().OfType<LabeledStatementSyntax>() select aLabelStatement; foreach (LabeledStatementSyntax lss in labelStatements) { retMethod.LabelStatements.Add(TraverseLabelStatements(lss)); } var goToStatements = from aGoToStatement in bs.ChildNodes().OfType<GotoStatementSyntax>() select aGoToStatement; foreach (GotoStatementSyntax gtss in goToStatements) { GoTo gt = TraverseGoToStatements(gtss); retMethod.GoToStatements.Add(gt); } //Preprocessors = new List<Preprocessor>(); //Base = new List<InvokedMethod>(); //Decisions = new Decisions(); var accessVarsDecl = from aAccessVarsDecl in bs.ChildNodes().OfType<LocalDeclarationStatementSyntax>() select aAccessVarsDecl; foreach (LocalDeclarationStatementSyntax ldss in accessVarsDecl) { Method tempMethod = TransverseAccessVars(ldss); retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables); retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods); } var ifStatements = from aIfStatement in bs.ChildNodes().OfType<IfStatementSyntax>() select aIfStatement; foreach (IfStatementSyntax iss in ifStatements) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = AllDecisions(TraverseIfStatements(iss, ref exitPoints)); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var elseStatements = from aElseStatements in bs.ChildNodes().OfType<ElseClauseSyntax>() select aElseStatements; foreach (ElseClauseSyntax ecs in elseStatements) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseElseClauses(ecs, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var whileLoops = from aWhileLoop in bs.ChildNodes().OfType<WhileStatementSyntax>() select aWhileLoop; foreach (WhileStatementSyntax wss in whileLoops) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseWhileLoops(wss, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var doWhileLoops = from aDoWhileLoop in bs.ChildNodes().OfType<DoStatementSyntax>() select aDoWhileLoop; foreach (DoStatementSyntax dss in doWhileLoops) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseDoStatements(dss, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var forLoops = from aForLoop in bs.ChildNodes().OfType<ForStatementSyntax>() select aForLoop; foreach (ForStatementSyntax fss in forLoops) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseForStatements(fss, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var foreachLoops = from aForeachLoop in bs.ChildNodes().OfType<ForEachStatementSyntax>() select aForeachLoop; foreach (ForEachStatementSyntax fess in foreachLoops) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseForEachStatements(fess, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var switches = from aSwitch in bs.ChildNodes().OfType<SwitchStatementSyntax>() select aSwitch; foreach (SwitchStatementSyntax sss in switches) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseSwitchStatements(sss, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var catches = from aCatch in bs.ChildNodes().OfType<CatchClauseSyntax>() select aCatch; foreach (CatchClauseSyntax ccs in catches) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = TraverseCatchClauses(ccs, ref exitPoints); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } var breaks = from aBreak in bs.ChildNodes().OfType<BreakStatementSyntax>() select aBreak; foreach (BreakStatementSyntax bss in breaks) { //TODO get breaks //note that breaks are NOT in retMethod.Decisions } var checks = from aCheck in bs.ChildNodes().OfType<CheckedStatementSyntax>() select aCheck; foreach (CheckedStatementSyntax css in checks) { //TODO get checks //note that checks are NOT in retMethod.Decisions } var continues = from aContinue in bs.ChildNodes().OfType<ContinueStatementSyntax>() select aContinue; foreach (ContinueStatementSyntax css in continues) { //TODO get continues //note that continues are NOT in retMethod.Decisions } var emptys = from aEmpty in bs.ChildNodes().OfType<EmptyStatementSyntax>() select aEmpty; foreach (EmptyStatementSyntax ess in emptys) { //TODO get emptys //note that emptys are NOT in retMethod.Decisions } var exprs = from aExpr in bs.ChildNodes().OfType<ExpressionStatementSyntax>() select aExpr; foreach (ExpressionStatementSyntax ess in exprs) { //TODO get expressions //note that expressions are NOT in retMethod.Decisions } var fixeds = from aFixed in bs.ChildNodes().OfType<FixedStatementSyntax>() select aFixed; foreach (FixedStatementSyntax fss in fixeds) { //TODO get fixed //note that these are NOT in retMethod.Decisions } var locks = from aLock in bs.ChildNodes().OfType<LockStatementSyntax>() select aLock; foreach (LockStatementSyntax lss in locks) { //TODO get lock //note that these are NOT in retMethod.Decisions } var returns = from aReturn in bs.ChildNodes().OfType<ReturnStatementSyntax>() select aReturn; foreach (ReturnStatementSyntax rss in returns) { retMethod.ExitPoints++; } var throws = from aThrow in bs.ChildNodes().OfType<ThrowStatementSyntax>() select aThrow; foreach (ThrowStatementSyntax tss in throws) { //TODO get throws //note that these are NOT in retMethod.Decisions } var trys = from aTry in bs.ChildNodes().OfType<TryStatementSyntax>() select aTry; foreach (TryStatementSyntax tss in trys) { //TODO get trys //note that these are NOT in retMethod.Decisions } var unsafes = from aUnsafe in bs.ChildNodes().OfType<UnsafeStatementSyntax>() select aUnsafe; foreach (UnsafeStatementSyntax uss in unsafes) { //TODO get unsafes //note that these are NOT in retMethod.Decisions } var usings = from aUsing in bs.ChildNodes().OfType<UsingStatementSyntax>() select aUsing; foreach (UsingStatementSyntax uss in usings) { //TODO get usings //note that these are NOT in retMethod.Decisions } var yields = from aYield in bs.ChildNodes().OfType<YieldStatementSyntax>() select aYield; foreach (YieldStatementSyntax yss in yields) { //TODO get yields //note that these are NOT in retMethod.Decisions } var invokedMethods = from aInvokedMethod in bs.ChildNodes().OfType<InvocationExpressionSyntax>() select aInvokedMethod; foreach (InvocationExpressionSyntax ies in invokedMethods) { Method tempMethod = TraverseInvocationExpression(ies); retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods); retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables); } //InvokedMethods = new List<InvokedMethod>(); } return retMethod; }