/// <summary>
/// Creates documentation comment trivia syntax.
/// </summary>
/// <param name="declarationSyntax">The declaration syntax.</param>
/// <returns>A DocumentationCommentTriviaSyntax.</returns>
private static DocumentationCommentTriviaSyntax CreateDocumentationCommentTriviaSyntax(MethodDeclarationSyntax declarationSyntax)
{
SyntaxList <SyntaxNode> list = SyntaxFactory.List <SyntaxNode>();
string methodComment = CommentHelper.CreateMethodComment(declarationSyntax.Identifier.ValueText);
list = list.AddRange(DocumentationHeaderHelper.CreateSummaryPartNodes(methodComment));
if (declarationSyntax.ParameterList.Parameters.Any())
{
foreach (ParameterSyntax parameter in declarationSyntax.ParameterList.Parameters)
{
string parameterComment = CommentHelper.CreateParameterComment(parameter);
list = list.AddRange(DocumentationHeaderHelper.CreateParameterPartNodes(parameter.Identifier.ValueText, parameterComment));
}
}
string returnType = declarationSyntax.ReturnType.ToString();
if (returnType != "void")
{
string returnComment = new ReturnCommentConstruction(declarationSyntax.ReturnType).Comment;
list = list.AddRange(DocumentationHeaderHelper.CreateReturnPartNodes(returnComment));
}
return(SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, list));
}
private SyntaxList <StatementSyntax> CreateConditionFunc(SyntaxList <StatementSyntax> statements, bool type, int ifCounter, List <string> mappedVariables)
{
SyntaxList <StatementSyntax> newStatements = new SyntaxList <StatementSyntax>();
StatementSyntax ifReturnStatement = null;
SyntaxList <StatementSyntax> variableMapping = new SyntaxList <StatementSyntax>(mappedVariables.Select(e => SyntaxFactory.ParseStatement($"var _{e} = {e};")));
var templateSignature = $"Func<Tuple<{string.Join(", ", Enumerable.Repeat("AutoTFOutput", Math.Max(mappedVariables.Count, 1)))}>>";
var ifTrueStatement = SyntaxFactory.ParseStatement($"{templateSignature} if{type}{ifCounter} = () => {{");
if (!statements.Any(e => { return(e.IsKind(SyntaxKind.ReturnStatement)); }))
{
if (mappedVariables.Count > 0)
{
ifReturnStatement = SyntaxFactory.ParseStatement($"return Tuple.Create({GetReturnVariablesString(mappedVariables, "_")});");
}
else
{
ifReturnStatement = SyntaxFactory.ParseStatement($"return new AutoTFOutput(session.Graph.Const(1), session);");
}
}
newStatements = newStatements.Add(ifTrueStatement);
newStatements = newStatements.AddRange(variableMapping);
newStatements = newStatements.AddRange(ReplaceVariables(statements, mappedVariables));
newStatements = newStatements.Add(ifReturnStatement);
newStatements = newStatements.Add(SyntaxFactory.ParseStatement("};"));
return(newStatements);
}
private static SyntaxList <UsingDirectiveSyntax> BuildUsingDirectives(IEnumerable <UsingDirectiveSyntax> apiUsings, SyntaxList <UsingDirectiveSyntax> wcfUsings)
{
var usingDirectives = new SyntaxList <UsingDirectiveSyntax>();
usingDirectives = usingDirectives.AddRange(apiUsings);
usingDirectives = usingDirectives.AddRange(wcfUsings);
return(usingDirectives);
}
private static SyntaxList <XmlNodeSyntax> CreateSummaryDocumentation(SyntaxList <XmlNodeSyntax> content, string text)
{
var summary = new List <SyntaxToken>();
summary.Add(XmlTextNewLine(TriviaList(), "\n", "\n", TriviaList()));
var commentLines = text.Split(new[] { "\n" }, StringSplitOptions.None);
for (int n = 0; n < commentLines.Length; n++)
{
var fixedCommentLine = $" {commentLines[n]}";
if (n != commentLines.Length - 1)
{
fixedCommentLine += "\n";
}
summary.Add(XmlTextLiteral(TriviaList(DocumentationCommentExterior("///")), fixedCommentLine, fixedCommentLine, TriviaList()));
}
summary.Add(XmlTextNewLine(TriviaList(), "\n", "\n", TriviaList()));
summary.Add(XmlTextLiteral(TriviaList(DocumentationCommentExterior("///")), " ", " ", TriviaList()));
return(content.AddRange(new List <XmlNodeSyntax>
{
XmlText().WithTextTokens(TokenList(XmlTextLiteral(TriviaList(DocumentationCommentExterior("///")), " ", " ", TriviaList()))),
XmlElement(XmlElementStartTag(XmlName(Identifier("summary"))), XmlElementEndTag(XmlName(Identifier("summary"))))
.WithContent(SingletonList <XmlNodeSyntax>(XmlText().WithTextTokens(TokenList(summary)))),
}));
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
SyntaxList <UsingDirectiveSyntax> list = new SyntaxList <UsingDirectiveSyntax>();
list = list.AddRange(m_temp);
return(node.WithUsings(list));
}
public override SyntaxNode VisitBlock(BlockSyntax node)
{
BlockSyntax block = (BlockSyntax)base.VisitBlock(node);
SyntaxList <StatementSyntax> curList = new SyntaxList <StatementSyntax>();
Dictionary <string, SyntaxNode> replacements = new Dictionary <string, SyntaxNode>();
int numbering = 1;
foreach (var stmt in block.Statements)
{
SyntaxList <StatementSyntax> preList = new SyntaxList <StatementSyntax>();
var stm = stmt.ReplaceNodes(nodes: stmt.DescendantNodes().Reverse(), computeReplacementNode: (original, origWithReplacedDesc) =>
{
Console.WriteLine(origWithReplacedDesc.GetType() + ": " + origWithReplacedDesc);
if (origWithReplacedDesc.IsKind(SyntaxKind.InvocationExpression) ||
origWithReplacedDesc.IsKind(SyntaxKind.ObjectCreationExpression))
{
return(SimplifyMethodAndConstructorInvocation(ref numbering, ref preList, original, origWithReplacedDesc));
}
return(origWithReplacedDesc);
});
curList = curList.AddRange(preList);
curList = curList.Add(stm);
}
return(block.WithStatements(curList));
}
private SyntaxTree mergeClasses(List <SyntaxTree> trees)
{
SyntaxTree result = null;
if (trees != null && trees.Count() > 0)
{
List <ClassDeclarationSyntax> classes = new List <ClassDeclarationSyntax>();
foreach (SyntaxTree tree in trees)
{
IEnumerable <ClassDeclarationSyntax> cs = this.getTopLevelClasses(tree);
if (cs != null && cs.Count() > 0)
{
classes.AddRange(cs);
}
}
if (classes.Count() > 0)
{
SyntaxList <MemberDeclarationSyntax> members = new SyntaxList <MemberDeclarationSyntax>();
members = members.AddRange(classes);
SyntaxNode root = SyntaxFactory.CompilationUnit().WithMembers(members);
if (root != null)
{
result = root.SyntaxTree;
}
}
}
return(result);
}
private SyntaxList <MemberDeclarationSyntax> HookedProperties(int id)
{
SyntaxList <MemberDeclarationSyntax> outp = new SyntaxList <MemberDeclarationSyntax>();
PropertyWithValueListenerGen gen = new PropertyWithValueListenerGen();
// Add clr class instance id property
if (shouldAddClrClassInstaceProp())
{
outp = outp.Add(gen.GetCodeVineClrIdFieldSyntax());
}
if (!shouldAddFieldHookProperties())
{
return(outp);
}
var classInfo = cSfileInfo.GetClassInfo(id);
foreach (var key in classInfo.FieldInfos.Keys)
{
var finfo = classInfo.FieldInfos[key];
// Todo - fix sending classInfo name directly to prop gen
var newProp = gen.GenerateProperty(finfo, classInfo.Name);
outp = outp.AddRange(newProp);
}
return(outp);
}
private void InsertStatements(MethodDeclarationSyntax method, string[] statements, bool clear = false)
{
SyntaxList <StatementSyntax> currentStatements = new SyntaxList <StatementSyntax>();
if (!clear)
{
currentStatements = method.Body.Statements;
}
var block = EvaluateStatements(statements);
SyntaxAnnotation annotation = null;
List <StatementSyntax> statementNodes = AnnotateStatements(block.Statements, out annotation);
currentStatements = currentStatements.AddRange(statementNodes);
var newBody = method.Body.WithStatements(currentStatements);
var newMethod = method.WithBody(newBody);
Replace(method, newMethod, null);
var annotatedNode = CurrentNode.GetAnnotatedNodes(annotation).First();
if (annotatedNode != null)
{
NextStep(annotatedNode);
}
}
public SyntaxNode CreateLocalVariableDeclaration(LocalDeclarationStatementSyntax node, string typeToMock)
{
var variable = node.Declaration.Variables.FirstOrDefault();
if (variable == null)
{
return(null);
}
var stubName = variable.Identifier.ValueText;
var stubDefDeclaration = CreateStubDefinitionDeclaration(stubName, typeToMock);
var symbol = node.Declaration.GetTypeSymbol(semanticModel) as INamedTypeSymbol;
var initializerExpression = CreateStubInitializerDeclarations(node, stubName, symbol);
var stubDeclaration = CreateStubDeclaration(node, stubName, variable.Identifier.ValueText);
var statements = new SyntaxList <StatementSyntax>();
statements = statements.AddRange(new StatementSyntax[] { stubDefDeclaration }.Union(initializerExpression).Union(new StatementSyntax[] { SyntaxFactory.LocalDeclarationStatement(stubDeclaration) }));
var wrapper = SyntaxFactory.Block(statements);
wrapper = wrapper.WithOpenBraceToken(SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken)) // to remove scope {}
.WithCloseBraceToken(SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken));
return(wrapper
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed));
}
private static SyntaxList <MemberDeclarationSyntax> MakeInterfaceSyntaxList(IEnumerable <MemberDeclarationSyntax> members)
{
var newMembers = ExtractInterfaceMembers(members).ToArray();
var syntaxList = new SyntaxList <MemberDeclarationSyntax>();
syntaxList = syntaxList.AddRange(newMembers);
return(syntaxList);
}
private SyntaxList <MemberDeclarationSyntax> BuildConstructor(SyntaxList <MemberDeclarationSyntax> members)
{
if (_constructor == null)
{
return(members);
}
return(members.AddRange(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(_constructor)));
}
private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxList <SyntaxNode> list)
{
Assert.Equal(0, list.Count);
SyntaxNode nodeD = SyntaxFactory.ParseExpression("D ");
SyntaxNode nodeE = SyntaxFactory.ParseExpression("E ");
var newList = list.Add(nodeD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.AddRange(new[] { nodeD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Insert(0, nodeD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.InsertRange(0, new[] { nodeD, nodeE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Remove(nodeD);
Assert.Equal(0, newList.Count);
Assert.Equal(-1, list.IndexOf(nodeD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.RemoveAt(0));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(1, nodeD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(-1, nodeD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { nodeD }));
Assert.Throws <ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { nodeD }));
Assert.Throws <ArgumentException>(() => list.Replace(nodeD, nodeE));
Assert.Throws <ArgumentException>(() => list.ReplaceRange(nodeD, new[] { nodeE }));
Assert.Throws <ArgumentNullException>(() => list.Add(null));
Assert.Throws <ArgumentNullException>(
() => list.AddRange((IEnumerable <SyntaxNode>)null)
);
Assert.Throws <ArgumentNullException>(() => list.Insert(0, null));
Assert.Throws <ArgumentNullException>(
() => list.InsertRange(0, (IEnumerable <SyntaxNode>)null)
);
}
private static PropertyDeclarationSyntax MakeInterfaceProperty(PropertyDeclarationSyntax propertySyntax)
{
var accessors = propertySyntax.AccessorList.Accessors.Select(f => MakeInterfaceAccessor(f));
var syntaxList = new SyntaxList <AccessorDeclarationSyntax>();
syntaxList = syntaxList.AddRange(accessors);
var accessorList = propertySyntax.AccessorList.WithAccessors(syntaxList);
return(propertySyntax.WithModifiers(new SyntaxTokenList()).WithAccessorList(accessorList));
}
private SyntaxList <StatementSyntax> ConvertIfStatement(IfStatementSyntax ifStatement,
SyntaxList <StatementSyntax> nextStatements,
SyntaxList <StatementSyntax> previousStatements,
int ifCounter)
{
var newStatements = new SyntaxList <StatementSyntax>();
var parentScopeVariables = GetDeclaredVariables(previousStatements);
var predicateStatement = SyntaxFactory.ParseStatement($"var predicate{ifCounter} = {ifStatement.Condition.ToString()};");
newStatements = newStatements.Add(predicateStatement);
//create the true Func
SyntaxList <StatementSyntax> ifTrueBlockStatements = ExpandBlock(ifStatement.Statement, ifCounter);
var ifTrueAssignedVariables = GetAssignedVariables(ifTrueBlockStatements);
//create the false Func
SyntaxList <StatementSyntax> ifFalseBlockStatements = ExpandBlock(ifStatement.Else.Statement, ifCounter);
var ifFalseAssignedVariables = GetAssignedVariables(ifFalseBlockStatements);
var mappedVariables = parentScopeVariables.Union(ifTrueAssignedVariables).Concat(parentScopeVariables.Union(ifTrueAssignedVariables)).Distinct().ToList();
var ifTrueStatements = CreateConditionFunc(ifTrueBlockStatements, true, ifCounter, mappedVariables);
var ifFalseStatements = CreateConditionFunc(ifFalseBlockStatements, false, ifCounter, mappedVariables);
newStatements = newStatements.AddRange(ifTrueStatements);
newStatements = newStatements.AddRange(ifFalseStatements);
var return_Variables = GetReturnVariablesString(mappedVariables);
var refactoredIf1 = SyntaxFactory.ParseStatement(
$"var res = new AutoCond<Tuple<{string.Join(",", Enumerable.Repeat("AutoTFOutput", Math.Max(1, mappedVariables.Count)).ToArray())}>>(predicate{ifCounter}, ifTrue{ifCounter}, ifFalse{ifCounter}, session);");
var refactoredIf2 = SyntaxFactory.ParseStatement(
$"res.Deconstruct({string.Join(", ", mappedVariables.Select(e => $"out {e}"))});");
newStatements = newStatements.Add(refactoredIf1);
newStatements = newStatements.Add(refactoredIf2);
newStatements = newStatements.AddRange(RefactorIfStatements(new SyntaxList <StatementSyntax>(nextStatements), ifCounter));
return(newStatements);
}
public SyntaxNode SwitchType(AssignmentExpressionSyntax assignment)
{
var left = assignment.Left as MemberAccessExpressionSyntax;
if (left == null)
{
return(null);
}
var right = assignment.Right as ObjectCreationExpressionSyntax;
var declarationTypeSymbol = semanticModel.GetTypeInfo(left).ConvertedType as INamedTypeSymbol;
if (declarationTypeSymbol == null)
{
return(null);
}
string typeToMock;
if (msTestHelper.IsStub(declarationTypeSymbol, out typeToMock))
{
if (typeToMock == null)
{
return(null);
}
var identifierName = left.Name.Identifier.ValueText;
var stubName = char.ToLowerInvariant(identifierName[0]) + identifierName.Substring(1);
var stubDefDeclaration = CreateStubDefinitionDeclaration(stubName, typeToMock)
.NormalizeWhitespace()
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
var initializerExpression = CreateStubInitializerDeclarations(assignment, stubName, declarationTypeSymbol);
var newAssignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, left, MoqStub.GetStubDefinitionIdentifierName(stubName))
.NormalizeWhitespace()
.WithLeadingTrivia(assignment.GetLeadingTrivia());
var statements = new SyntaxList <StatementSyntax>();
statements = statements.AddRange(new StatementSyntax[] { stubDefDeclaration }.Union(initializerExpression).Union(new StatementSyntax[] { SyntaxFactory.ExpressionStatement(newAssignment) }));
var wrapper = SyntaxFactory.Block(statements);
wrapper = wrapper.WithOpenBraceToken(SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken)) // to remove scope {}
.WithCloseBraceToken(SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken));
return(wrapper
.WithLeadingTrivia(assignment.GetLeadingTrivia())
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed));
}
return(null);
}
public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)
{
if (node.Usings.Count > 0)
{
var newUsingDirectives = new SyntaxList <UsingDirectiveSyntax>();
var nodesToKeep = node.Usings.Where(directive => directive.Name.ToString() != Constants.Proto.USING_STATEMENT).ToArray();
newUsingDirectives = newUsingDirectives.AddRange(nodesToKeep);
var leadTriv = node.GetLeadingTrivia();
node = node.WithUsings(newUsingDirectives);
node = node.WithLeadingTrivia(leadTriv);
}
return(base.VisitCompilationUnit(node));
}
public SyntaxList <UsingDirectiveSyntax> Convert(ImportClause node)
{
SyntaxList <UsingDirectiveSyntax> usings = new SyntaxList <UsingDirectiveSyntax>();
if (node.Name != null) // default
{
ImportDeclaration import = node.Ancestor(NodeKind.ImportDeclaration) as ImportDeclaration;
Syntax.Document fromDoc = import?.FromDocument;
Node definition = fromDoc?.GetExportDefaultTypeDefinition();
if (definition != null)
{
string definitionPackage = definition.Document.GetPackageName();
string package = import.Document.GetPackageName();
string name = node.Name.Text;
string propertyName = (string)definition.GetValue("NameText");
if (package != definitionPackage || name != propertyName)
{
UsingDirectiveSyntax usingSyntax = SyntaxFactory.UsingDirective(
SyntaxFactory.NameEquals(name),
SyntaxFactory.ParseName($"{definitionPackage}.{propertyName}"));
usings = usings.Add(usingSyntax);
}
}
}
if (node.NamedBindings != null)
{
switch (node.NamedBindings.Kind)
{
case NodeKind.NamespaceImport:
UsingDirectiveSyntax usingSyntax = node.NamedBindings.ToCsNode <UsingDirectiveSyntax>();
if (usingSyntax != null)
{
usings = usings.Add(usingSyntax);
}
break;
case NodeKind.NamedImports:
usings = usings.AddRange(node.NamedBindings.ToCsNode <IEnumerable <UsingDirectiveSyntax> >());
break;
default:
break;
}
}
return(usings);
}
static SyntaxList <StatementSyntax> CreateSectionStatements(StatementSyntax source)
{
var result = new SyntaxList <StatementSyntax>();
if (source is BlockSyntax)
{
var block = source as BlockSyntax;
result = result.AddRange(block.Statements);
}
else
{
result = result.Add(source);
}
return(result);
}
/// <summary>
/// Creates documentation comment trivia syntax.
/// </summary>
/// <param name="declarationSyntax">The declaration syntax.</param>
/// <returns>A DocumentationCommentTriviaSyntax.</returns>
private static DocumentationCommentTriviaSyntax CreateDocumentationCommentTriviaSyntax(ConstructorDeclarationSyntax declarationSyntax)
{
SyntaxList <XmlNodeSyntax> list = SyntaxFactory.List <XmlNodeSyntax>();
bool isPrivate = false;
if (declarationSyntax.Modifiers.Any(SyntaxKind.PrivateKeyword))
{
isPrivate = true;
}
string comment = CommentHelper.CreateConstructorComment(declarationSyntax.Identifier.ValueText, isPrivate);
list = list.AddRange(DocumentationHeaderHelper.CreateSummaryPartNodes(comment));
if (declarationSyntax.ParameterList.Parameters.Any())
{
foreach (ParameterSyntax parameter in declarationSyntax.ParameterList.Parameters)
{
string parameterComment = CommentHelper.CreateParameterComment(parameter);
list = list.AddRange(DocumentationHeaderHelper.CreateParameterPartNodes(parameter.Identifier.ValueText, parameterComment));
}
}
return(SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, list));
}
public static ClassDeclarationSyntax AddSyntaxNode(ClassDeclarationSyntax parent, SyntaxNode child)
{
child = child.NormalizeWhitespace();
List <MemberDeclarationSyntax> syntaxLijstje = new List <MemberDeclarationSyntax>();
syntaxLijstje.AddRange(parent.ChildNodes().OfType <MemberDeclarationSyntax>());
syntaxLijstje.AddRange(child.ChildNodes().OfType <MemberDeclarationSyntax>());
var syntaxList = new SyntaxList <MemberDeclarationSyntax>();
syntaxList.AddRange(syntaxLijstje);
var result = parent.WithMembers(syntaxList).NormalizeWhitespace();
return(result);
}
public CSharpSyntaxNode Convert(TemplateExpression node)
{
SyntaxList <InterpolatedStringContentSyntax> contents = new SyntaxList <InterpolatedStringContentSyntax>();
InterpolatedStringContentSyntax head = node.Head.ToCsNode <InterpolatedStringContentSyntax>();
if (head != null)
{
contents = contents.Add(head);
}
foreach (Node templateSpan in node.TemplateSpans)
{
var content = templateSpan.ToCsNode <SyntaxList <InterpolatedStringContentSyntax> >();
contents = contents.AddRange(content);
}
return(SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), contents));
}
public CSharpSyntaxNode Convert(JSDocComment node)
{
SyntaxList <XmlNodeSyntax> comments = SyntaxFactory.List(this.CreateXmlTextBlock("summary", this.GetComment(node)));
if (node.Tags.Count > 0)
{
foreach (Node tag in node.Tags)
{
if (!this.IsDocCommentTag(tag))
{
comments = comments.AddRange(tag.ToCsNode <SyntaxList <XmlNodeSyntax> >());
}
}
}
comments = comments.Add(this.CreateXmlTextNewLine());
return(SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, comments));
}
private static SyntaxList <XmlNodeSyntax> CreateParameterDocumentation(SyntaxList <XmlNodeSyntax> content, Parameter parameter)
{
return(content.AddRange(new List <XmlNodeSyntax> {
XmlText().WithTextTokens(
TokenList(
new[]
{
XmlTextNewLine(
TriviaList(),
"\n",
"\n",
TriviaList()),
XmlTextLiteral(
TriviaList(
DocumentationCommentExterior("///")),
" ",
" ",
TriviaList())
})),
XmlExampleElement(SingletonList <XmlNodeSyntax>(
XmlText().WithTextTokens(
TokenList(
XmlTextLiteral(
TriviaList(),
parameter.XmlDocumentation,
parameter.XmlDocumentation,
TriviaList())))))
.WithStartTag(XmlElementStartTag(
XmlName(
Identifier("param")))
.WithAttributes(
SingletonList <XmlAttributeSyntax>(
XmlNameAttribute(
XmlName(
Identifier(" name")),
Token(SyntaxKind.DoubleQuoteToken),
IdentifierName(parameter.Name),
Token(SyntaxKind.DoubleQuoteToken)))))
.WithEndTag(
XmlElementEndTag(
XmlName(
Identifier("param"))))
}));
}
public ClassDeclarationSyntax RewriteFieldDeclaration(FieldDeclarationSyntax node)
{
var parent = node.Parent as ClassDeclarationSyntax;
var variables = node.Declaration.Variables;
var newmems = new SyntaxList <MemberDeclarationSyntax>();
var oldmems = parent.Members;
//var hits = variables.Where(x => this.annotationDCIs.Contains(SemanticModel.GetDeclaredSymbol(x).ToString()));
//if (hits.Any())
var hits = variables.Where(variable => SemanticModel.GetDeclaredSymbol(variable).ToString().Equals(AnnotationDCI));
if (hits.Any())
{
//RBLogger.Info("Got a hit");
oldmems = oldmems.Remove(node);
//var parent = node.Parent as ClassDeclarationSyntax;
//parent = parent.RemoveNode(node, SyntaxRemoveOptions.KeepDirectives | SyntaxRemoveOptions.KeepExteriorTrivia);
//parent = parent.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
var oldmodifiers = node.Modifiers;
foreach (var variable in node.Declaration.Variables)
{
var varList = SyntaxFactory.SeparatedList <VariableDeclaratorSyntax>();
variables = variables.Add(variable);
var vardecl = SyntaxFactory.VariableDeclaration(node.Declaration.Type, varList);
var fielddecl = SyntaxFactory.FieldDeclaration(vardecl);
Contract.Assert(fielddecl != null);
fielddecl = fielddecl.AddModifiers(oldmodifiers.ToArray());
//if (hits.Contains(variable) && !oldmodifiers.Any(x => x.Text.Equals("readonly")))
if (hits.Contains(variable) && !oldmodifiers.Any(x => x.Equals(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))))
{
//fielddecl = fielddecl.AddModifiers(SyntaxFactory.ParseToken(@"readonly"));
fielddecl = fielddecl.AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
fielddecl = fielddecl.WithTrailingTrivia(SyntaxFactory.Comment(Constants.String.Signature));
}
newmems = newmems.Add(fielddecl);
}
//newmems = newmems.AddRange(parent.Members);
newmems = newmems.AddRange(oldmems);
return(parent.WithMembers(newmems));
}
return(node.Parent as ClassDeclarationSyntax);
}
static SyntaxList <StatementSyntax> CreateSectionStatements(StatementSyntax source)
{
var result = new SyntaxList <StatementSyntax>();
if (source is BlockSyntax)
{
var block = source as BlockSyntax;
result = result.AddRange(block.Statements);
}
else
{
result = result.Add(source);
}
if (!(result.LastOrDefault() is ReturnStatementSyntax))
{
result = result.Add(SyntaxFactory.BreakStatement());
}
return(result);
}
private SyntaxList <StatementSyntax> RefactorIfStatements(SyntaxList <StatementSyntax> statements, int ifCounter)
{
var newStatements = new SyntaxList <StatementSyntax>();
int position = 0;
while (position < statements.Count)
{
var statement = statements[position];
if (statement.IsKind(SyntaxKind.IfStatement))
{
newStatements = newStatements.AddRange(ConvertIfStatement(statement as IfStatementSyntax, new SyntaxList <StatementSyntax>(statements.Skip(position + 1)), new SyntaxList <StatementSyntax>(statements.Take(position)), ++ifCounter));
break;
}
else
{
newStatements = newStatements.Add(statement);
position++;
}
}
return(newStatements);
}
public static NamespaceDeclarationSyntax AppendUsing(
this NamespaceDeclarationSyntax node,
params string[] usingDirectives)
{
List <string> list = node.DescendantNodes((Func <SyntaxNode, bool>)(p => !(p is ClassDeclarationSyntax)), false).OfType <UsingDirectiveSyntax>().Select <UsingDirectiveSyntax, string>((Func <UsingDirectiveSyntax, string>)(p => p.Name.ToString())).ToList <string>();
foreach (string usingDirective in usingDirectives)
{
if (usingDirective != null && !list.Contains(usingDirective))
{
list.Add(usingDirective);
}
}
list.Sort();
SyntaxList <UsingDirectiveSyntax> usings = node.Usings;
while (usings.Count > 0)
{
usings = usings.RemoveAt(0);
}
usings = usings.AddRange(list.Select <string, UsingDirectiveSyntax>((Func <string, UsingDirectiveSyntax>)(u => u.ToUsing())));
return(node.WithUsings(usings));
}
private static SyntaxList <AttributeListSyntax> SortAttributes(SyntaxList <AttributeListSyntax> attributeLists)
{
if (attributeLists.Count == 0)
{
return(attributeLists);
}
var sortedAttributeLists = new SyntaxList <AttributeListSyntax>();
var firstLeadingTrivia = attributeLists[0].GetLeadingTrivia();
var secondLeadingTrivia = firstLeadingTrivia;
if (attributeLists.Count > 1)
{
secondLeadingTrivia = attributeLists[1].GetLeadingTrivia();
}
var orderedAttributeLists = attributeLists.Select(q => q.WithLeadingTrivia(secondLeadingTrivia)).OrderBy(q => q.Attributes.ToString());
sortedAttributeLists = sortedAttributeLists.AddRange(orderedAttributeLists);
sortedAttributeLists = sortedAttributeLists.Replace(sortedAttributeLists[0], sortedAttributeLists[0].WithLeadingTrivia(firstLeadingTrivia));
return(sortedAttributeLists);
}
public override string GetSyntaxContent(MemberType typeKind, SyntaxNode syntaxNode)
{
string syntaxStr = null;
int openBracketIndex = -1;
switch (typeKind)
{
case MemberType.Class:
{
var syntax = syntaxNode as ClassDeclarationSyntax;
Debug.Assert(syntax != null);
if (syntax == null)
{
break;
}
syntaxStr
= syntax
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.WithBaseList(null)
.WithMembers(new SyntaxList <MemberDeclarationSyntax>())
.NormalizeWhitespace()
.ToString();
openBracketIndex = syntaxStr.IndexOf(syntax.OpenBraceToken.ValueText);
if (openBracketIndex > -1)
{
syntaxStr = syntaxStr.Substring(0, openBracketIndex).Trim();
}
else
{
syntaxStr = syntaxStr.Trim();
}
break;
};
case MemberType.Enum:
{
var syntax = syntaxNode as EnumDeclarationSyntax;
Debug.Assert(syntax != null);
if (syntax == null)
{
break;
}
syntaxStr
= syntax
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.WithBaseList(null)
.WithMembers(new SeparatedSyntaxList <EnumMemberDeclarationSyntax>())
.NormalizeWhitespace()
.ToString();
openBracketIndex = syntaxStr.IndexOf(syntax.OpenBraceToken.ValueText);
if (openBracketIndex > -1)
{
syntaxStr = syntaxStr.Substring(0, openBracketIndex).Trim();
}
else
{
syntaxStr = syntaxStr.Trim();
}
break;
};
case MemberType.Interface:
{
var syntax = syntaxNode as InterfaceDeclarationSyntax;
Debug.Assert(syntax != null);
if (syntax == null)
{
break;
}
syntaxStr =
syntax
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.WithBaseList(null)
.WithMembers(new SyntaxList <MemberDeclarationSyntax>())
.NormalizeWhitespace()
.ToString();
openBracketIndex = syntaxStr.IndexOf(syntax.OpenBraceToken.ValueText);
if (openBracketIndex > -1)
{
syntaxStr = syntaxStr.Substring(0, openBracketIndex).Trim();
}
else
{
syntaxStr = syntaxStr.Trim();
}
break;
};
case MemberType.Struct:
{
var syntax = syntaxNode as StructDeclarationSyntax;
Debug.Assert(syntax != null);
if (syntax == null)
{
break;
}
syntaxStr = syntax
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.WithBaseList(null)
.WithMembers(new SyntaxList <MemberDeclarationSyntax>())
.NormalizeWhitespace()
.ToString();
openBracketIndex = syntaxStr.IndexOf(syntax.OpenBraceToken.ValueText);
if (openBracketIndex > -1)
{
syntaxStr = syntaxStr.Substring(0, openBracketIndex).Trim();
}
else
{
syntaxStr = syntaxStr.Trim();
}
break;
};
case MemberType.Delegate:
{
var syntax = syntaxNode as DelegateDeclarationSyntax;
Debug.Assert(syntax != null);
if (syntax == null)
{
break;
}
syntaxStr = syntax
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.NormalizeWhitespace()
.ToString().Trim();
break;
};
case MemberType.Method:
{
var syntax = syntaxNode as MethodDeclarationSyntax;
if (syntax != null)
{
syntaxStr = syntax.WithBody(null)
.NormalizeWhitespace()
.ToString()
.Trim();
}
break;
};
case MemberType.Constructor:
{
var syntax = syntaxNode as ConstructorDeclarationSyntax;
if (syntax != null)
{
syntaxStr = syntax.WithBody(null)
.NormalizeWhitespace()
.ToString()
.Trim();
}
break;
};
case MemberType.Field:
{
var syntax = syntaxNode as VariableDeclaratorSyntax;
if (syntax != null)
{
syntaxStr = syntax
.WithInitializer(null)
.NormalizeWhitespace()
.ToString()
.Trim();
}
break;
};
case MemberType.Event:
{
var syntax = syntaxNode as EventDeclarationSyntax;
if (syntax != null)
{
syntaxStr = syntax.WithoutTrivia().NormalizeWhitespace().ToString().Trim();
syntaxStr = Regex.Replace(syntaxStr, @"\s*\{(\S|\s)*", ";");
}
break;
};
case MemberType.Property:
{
Debug.Assert(syntaxNode is PropertyDeclarationSyntax || syntaxNode is IndexerDeclarationSyntax);
var syntax = syntaxNode as PropertyDeclarationSyntax;
if (syntax != null)
{
var accessorList = syntax.AccessorList.Accessors;
var simplifiedAccessorList = accessorList.Select(s => s.WithBody(null).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
SyntaxList <AccessorDeclarationSyntax> syntaxList = new SyntaxList <AccessorDeclarationSyntax>();
syntaxList = syntaxList.AddRange(simplifiedAccessorList);
var simplifiedSyntax = syntax.WithAccessorList(SyntaxFactory.AccessorList(syntaxList));
syntaxStr = simplifiedSyntax.NormalizeWhitespace().ToString().Trim();
}
else
{
var syntaxIndexer = syntaxNode as IndexerDeclarationSyntax;
if (syntaxIndexer != null)
{
var accessorList = syntaxIndexer.AccessorList.Accessors;
var simplifiedAccessorList = accessorList.Select(s => s.WithBody(null).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
SyntaxList <AccessorDeclarationSyntax> syntaxList = new SyntaxList <AccessorDeclarationSyntax>();
syntaxList = syntaxList.AddRange(simplifiedAccessorList);
var simplifiedSyntax = syntaxIndexer.WithAccessorList(SyntaxFactory.AccessorList(syntaxList));
syntaxStr = simplifiedSyntax.NormalizeWhitespace().ToString().Trim();
}
}
break;
};
}
if (string.IsNullOrEmpty(syntaxStr))
{
syntaxStr = syntaxNode.NormalizeWhitespace().ToString().Trim();
}
return(syntaxStr);
}
