Ledgerscope.CodeGen.Decorators/OutputGenerator.cs at master · ledgerscope/Ledgerscope.CodeGen.Decorators · GitHub

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Generic;
using System.Linq;

namespace Ledgerscope.CodeGen.Decorators
{
    internal static class OutputGenerator
    {
        public static NamespaceDeclarationSyntax GenerateOutputs(INamedTypeSymbol type)
        {
            var interfaceName = type.Name;
            var className = type.Name.Substring(1);
            var decoratorName = className + "Decorator";

            var constructorParamName = char.ToLower(interfaceName[1]) + interfaceName.Substring(2);
            var fieldName = "_" + constructorParamName;

            var parsedType = type.ToTypeSyntax();

            var ancestorInterfaces = type.AllInterfaces;
            var ancestorMembers = ancestorInterfaces.SelectMany(a => a.GetMembers());
            var members = type.GetMembers().Concat(ancestorMembers).ToArray();

            var modifier = SyntaxFacts.GetText(type.DeclaredAccessibility);
            var accessibilityModifier = SyntaxFactory.Token(SyntaxFacts.GetKeywordKind(modifier));

            var classDeclaration = SyntaxFactory.ClassDeclaration(decoratorName)
                    .AddModifiers(accessibilityModifier, SyntaxFactory.Token(SyntaxKind.AbstractKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword))
                    .AddBaseListTypes(SyntaxFactory.SimpleBaseType(parsedType))
                    .AddMembers(getField(parsedType, fieldName))
                    .AddMembers(getConstructor(decoratorName, constructorParamName, parsedType, fieldName))
                    .AddMembers(getMembers(type, fieldName).ToArray());

            if (type.TypeParameters.Any())
            {
                classDeclaration = classDeclaration.AddTypeParameterListParameters(type.TypeParameters.Select(tp => SyntaxFactory.TypeParameter(tp.Name)).ToArray());

                foreach (var tp in type.TypeParameters)
                {
                    var clause = tp.GetTypeParameterConstraintClauses();
                    if (clause.Length != 0)
                    {
                        classDeclaration = classDeclaration.AddConstraintClauses(clause);
                    }
                }
            }

            return SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(type.ContainingNamespace.ToDisplayString()))
                .AddMembers(classDeclaration);
        }

        private static FieldDeclarationSyntax getField(TypeSyntax typeSyntax, string fieldName)
        {
            return SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(typeSyntax)
                    .AddVariables(SyntaxFactory.VariableDeclarator(fieldName))).AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
        }

        private static ConstructorDeclarationSyntax getConstructor(string decoratorName, string constructorParamName, TypeSyntax typeSyntax, string fieldName)
        {
            return SyntaxFactory.ConstructorDeclaration(decoratorName)
                    .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
                    .AddParameterListParameters(SyntaxFactory.Parameter(SyntaxFactory.Identifier(constructorParamName)).WithType(typeSyntax))
                    .WithBody(
                        SyntaxFactory.Block(
                            SyntaxFactory.ExpressionStatement(
                                SyntaxFactory.AssignmentExpression(
                                    SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(fieldName), SyntaxFactory.IdentifierName(constructorParamName)))));
        }

        private static IEnumerable<MemberDeclarationSyntax> getMembers(INamedTypeSymbol type, string fieldName)
        {
            var members = type.GetAllInterfaceMembers();

            foreach (var member in members)
            {
                if (member is IMethodSymbol { MethodKind: MethodKind.Ordinary } method)
                {

                    SimpleNameSyntax identifierName;
                    if (method.TypeParameters.Any())
                    {
                        identifierName = SyntaxFactory.GenericName(SyntaxFactory.Identifier(method.Name))
                            .AddTypeArgumentListArguments(method.TypeParameters.Select(tp => SyntaxFactory.IdentifierName(tp.Name)).ToArray());
                    }
                    else
                    {
                        identifierName = SyntaxFactory.IdentifierName(method.Name);
                    }

                    var methodCall = SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(fieldName), identifierName))
                        .AddArgumentListArguments(method.Parameters.Select(p => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(p.Name))).ToArray());

                    StatementSyntax statement;
                    if (method.ReturnType.SpecialType == SpecialType.System_Void)
                    {
                        statement = SyntaxFactory.ExpressionStatement(methodCall);
                    }
                    else
                    {
                        statement = SyntaxFactory.ReturnStatement(methodCall);
                    }

                    var methodDeclaration = SyntaxFactory.MethodDeclaration(method.ReturnType.ToTypeSyntax(), method.Name)
                        .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.VirtualKeyword))
                        .AddParameterListParameters(method.Parameters.Select(p => SyntaxFactory.Parameter(SyntaxFactory.Identifier(p.Name)).WithType(p.Type.ToTypeSyntax())).ToArray())
                        .WithBody(SyntaxFactory.Block(statement));

                    if (method.TypeParameters.Any())
                    {
                        methodDeclaration = methodDeclaration.AddTypeParameterListParameters(method.TypeParameters.Select(tp => SyntaxFactory.TypeParameter(tp.Name)).ToArray());

                        foreach (var tp in method.TypeParameters)
                        {
                            var clause = tp.GetTypeParameterConstraintClauses();
                            if (clause.Length != 0)
                            {
                                methodDeclaration = methodDeclaration.AddConstraintClauses(clause);
                            }
                        }
                    }

                    yield return methodDeclaration;

                }
                else if (member is IPropertySymbol property)
                {

                    yield return SyntaxFactory.PropertyDeclaration(property.Type.ToTypeSyntax(), property.Name)
                        .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.VirtualKeyword))
                        .AddAccessorListAccessors(
                            SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
                                .WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(fieldName), SyntaxFactory.IdentifierName(property.Name))))),
                            SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
                                .WithBody(SyntaxFactory.Block(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(fieldName), SyntaxFactory.IdentifierName(property.Name)), SyntaxFactory.IdentifierName("value"))))));
                }
            }
        }
    }
}