private static SyntaxList<MemberDeclarationSyntax> MakeInterfaceSyntaxList(IEnumerable<MemberDeclarationSyntax> members) { var newMembers = ExtractInterfaceMembers(members).ToArray(); var syntaxList = new SyntaxList<MemberDeclarationSyntax>(); syntaxList = syntaxList.AddRange(newMembers); return syntaxList; }
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 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 SyntaxNode AddLambdaThis(SyntaxNode node) { //SyntaxTreeHelper.PrintTree(node); if (!node.GetAnnotations("haslambdas").Any()) { return node; } /*if (!node.DescendantNodes().OfType<ParenthesizedLambdaExpressionSyntax>().Any()) { return node; }*/ var stmt = CreateLambdaThis(); var stmtlist = new SyntaxList<StatementSyntax>(); stmtlist = stmtlist.Add(stmt); stmtlist = stmtlist.AddRange(node.ChildNodes().OfType<StatementSyntax>()); node = SyntaxFactory.Block(stmtlist); return node; }
private 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); } var lastStatement = result.LastOrDefault(); if (!(lastStatement is ReturnStatementSyntax || lastStatement is ThrowStatementSyntax)) { result = result.Add(SyntaxFactory.BreakStatement()); } return result; }
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); }
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; }