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;
}
