Software/Visual_Studio/SideChains/MaterialDesignInXamlToolkit-master/mdresgen/IconDataFactorySyntaxRewriter.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace mdresgen
{
    internal class IconDataFactorySyntaxRewriter : CSharpSyntaxRewriter
    {
        private readonly IEnumerable<Tuple<string, string>> _nameDataPairs;

        public IconDataFactorySyntaxRewriter(IEnumerable<Tuple<string, string>> nameDataPairs, bool visitIntoStructuredTrivia = false) : base(visitIntoStructuredTrivia)
        {
            if (nameDataPairs == null) throw new ArgumentNullException(nameof(nameDataPairs));

            _nameDataPairs = nameDataPairs;
        }

        public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
        {
            if (node.Kind() != SyntaxKind.CollectionInitializerExpression)
                return node;

            var initialiserExpressions = GetInitializerItems(_nameDataPairs);
            var complexElementInitializerExpression = SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression, initialiserExpressions);

            return complexElementInitializerExpression;
        }

        private SeparatedSyntaxList<ExpressionSyntax> GetInitializerItems(
            IEnumerable<Tuple<string, string>> nameDataPairs)
        {
            var initializerExpressionSyntaxList = nameDataPairs.Select(pair =>
            {
                //create a member access expression            
                var memberAccessExpressionSyntax =
                    SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                        SyntaxFactory.IdentifierName("PackIconKind"),
                        SyntaxFactory.IdentifierName((string) pair.Item1));

                //create a string literal expression
                var literalExpressionSyntax = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                    SyntaxFactory.Literal((string) pair.Item2));

                var separatedSyntaxList = SyntaxFactory.SeparatedList<ExpressionSyntax>(new ExpressionSyntax[] { memberAccessExpressionSyntax, literalExpressionSyntax });
                var initializerExpressionSyntax = SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression, separatedSyntaxList);
                return (ExpressionSyntax)initializerExpressionSyntax;
            });

            var result = SyntaxFactory.SeparatedList(initializerExpressionSyntaxList);

            return result;
        }
    }
}