C# SyntaxList.AddRange方法代码示例

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