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