CSharpToTypescript/CSharpToTypescriptConverter.cs at master · jo-neves/CSharpToTypescript · 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
143
144
145
/*
 * Copyright (c) 2019-2021 João Pedro Martins Neves (shivayl) - All Rights Reserved.
 *
 * CSharpToTypescript is licensed under the GPLv3.0 license (GNU General Public License v3.0),
 * located in the root of this project, under the name "LICENSE.md".
 *
 */

using System;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;

using RoslynTypeScript.Translation;

using CSharpToTypescript.Contract;

namespace CSharpToTypescript
{
    public class CSharpToTypescriptConverter : ICSharpToTypescriptConverter
    {
        private MetadataReference mscorlib;
        private MetadataReference Mscorlib
        {
            get
            {
                if (this.mscorlib != null)
                {
                    return this.mscorlib;
                }

                try
                {
                    this.mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
                }
                catch (Exception)
                {
                    this.mscorlib = this.MscorlibAssLoader();
                }

                return this.mscorlib;
            }
        }

        private PortableExecutableReference MscorlibAssLoader()
        {
            const string mscorlibResourceName = "CSharpToTypescript.lib.net5.mscorlib.dll";

            Assembly curAss = Assembly.GetExecutingAssembly();
            using (Stream assStream = curAss.GetManifestResourceStream(mscorlibResourceName))
            {
                byte[] buffer = new byte[(int)assStream.Length];
                assStream.Read(buffer, 0, (int)assStream.Length);

                return MetadataReference.CreateFromStream(assStream);
            }
        }

        public string ConvertToTypescript(string text, ISettingStore settingStore)
        {
            try
            {
                CSharpSyntaxTree tree = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText(text);

                // detect to see if it's actually C# sourcode by checking whether it has any error
                if (tree.GetDiagnostics().Any(f => f.Severity == DiagnosticSeverity.Error))
                {
                    return null;
                }

                CSharpSyntaxNode root = tree.GetRoot();

                // if it only contains comments, just return the original texts
                if (IsEmptyRoot(root))
                {
                    return null;
                }

                if (settingStore.IsConvertToInterface)
                {
                    root = ClassToInterfaceReplacement.ReplaceClass(root);
                }

                if (settingStore.IsConvertMemberToCamelCase)
                {
                    root = MakeMemberCamelCase.Make(root);
                }

                if (settingStore.IsConvertListToArray)
                {
                    root = ListToArrayReplacement.ReplaceList(root);
                }

                if (settingStore.ReplacedTypeNameArray.Length > 0)
                {
                    root = TypeNameReplacement.Replace(settingStore.ReplacedTypeNameArray, root);
                }

                if (settingStore.AddIPrefixInterfaceDeclaration)
                {
                    root = AddIPrefixInterfaceDeclaration.AddIPrefix(root);
                }

                if (settingStore.IsInterfaceOptionalProperties)
                {
                    root = OptionalInterfaceProperties.AddOptional(root);
                }

                tree = (CSharpSyntaxTree)root.SyntaxTree;

                var translationNode = TF.Get(root, null);

                var compilation = CSharpCompilation.Create(
                    "TemporaryCompilation",
                     syntaxTrees: new[] { tree },
                     references: new[] { Mscorlib }
                );

                var model = compilation.GetSemanticModel(tree);

                translationNode.Compilation = compilation;
                translationNode.SemanticModel = model;

                translationNode.ApplyPatch();
                return translationNode.Translate();
            }
            catch (Exception ex)
            {
                // TODO
                // swallow exception .!!!!!!!!!!!!!!!!!!!!!!!
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
            }

            return null;
        }

        private bool IsEmptyRoot(SyntaxNode root)
        {
            return !root.DescendantNodes().Any();
        }
    }
}