Merge pull request #1 from roman-g/master

mifopen · web-flow · commit 1947b9192909 · 2020-05-14T13:04:36.000+05:00
Converting C# const fields into TS literal types
diff --git a/src/LazyCoder/BaseCoder.cs b/src/LazyCoder/BaseCoder.cs
@@ -67,6 +67,17 @@ protected virtual TsEnumValue Rewrite(CsEnumValue x)
 
         protected virtual TsInterface Rewrite(CsClass csClass)
         {
+            var properties = csClass.Members
+                .Where(x => !x.IsStatic)
+                .OfType<CsProperty>()
+                .Select(Rewrite)
+                .ToArray();
+
+            var fields = csClass.Members
+                .OfType<CsField>()
+                .Select(Rewrite)
+                .ToArray();
+
             return new TsInterface
                    {
                        CsType = csClass.CsType,
@@ -80,11 +91,7 @@ protected virtual TsInterface Rewrite(CsClass csClass)
                                         TsType.From(new CsType(csClass.CsType.OriginalType
                                                                       .BaseType))
                                     },
-                       Properties = csClass.Members
-                                           .Where(x => !x.IsStatic)
-                                           .OfType<CsProperty>()
-                                           .Select(Rewrite)
-                                           .ToArray()
+                       Properties = properties.Concat(fields).ToArray()
                    };
         }
 
@@ -120,7 +127,7 @@ protected virtual TsInterface Rewrite(CsStruct csStruct)
                    };
         }
 
-        protected virtual TsTypeMember Rewrite(CsTypeMember csTypeMember)
+        protected virtual TsTypeMember? Rewrite(CsTypeMember csTypeMember)
         {
             switch (csTypeMember)
             {
@@ -133,6 +140,15 @@ protected virtual TsTypeMember Rewrite(CsTypeMember csTypeMember)
                                Type = TsType.From(csProperty.Type,
                                                   forceNullable)
                            };
+                case CsField csField:
+                    if (csField.Value == null)
+                        return null;
+
+                    return new TsPropertySignature
+                    {
+                        Name = csField.Name,
+                        Type = TsType.FromLiteral(csField.Value)
+                    };
                 default:
                     throw new ArgumentOutOfRangeException(nameof(csTypeMember),
                                                           csTypeMember.GetType().Name, null);
diff --git a/src/LazyCoder/CSharp/CsField.cs b/src/LazyCoder/CSharp/CsField.cs
@@ -0,0 +1,8 @@
+﻿namespace LazyCoder.CSharp
+{
+    public class CsField: CsTypeMember
+    {
+        public CsType Type { get; set; }
+        public CsLiteral? Value { get; set; }
+    }
+}
diff --git a/src/LazyCoder/CSharp/CsLiteral.cs b/src/LazyCoder/CSharp/CsLiteral.cs
@@ -0,0 +1,8 @@
+﻿namespace LazyCoder.CSharp
+{
+    public class CsLiteral
+    {
+        public CsType Type { get; set; }
+        public object Value { get; set; }
+    }
+}
diff --git a/src/LazyCoder/CsDeclarationFactory.cs b/src/LazyCoder/CsDeclarationFactory.cs
@@ -45,7 +45,9 @@ public static CsDeclaration Create(Type type)
                                                       .ToArray()
                                                 : Array.Empty<string>(),
                            Members = type.GetDefinition()
-                                         .GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+                                         .GetMembers(BindingFlags.Public | BindingFlags.Instance |
+                                                     BindingFlags.DeclaredOnly |
+                                                     BindingFlags.Static)
                                          .Where(m => !typeof(object)
                                                       .GetMembers()
                                                       .Select(me => me.Name)
@@ -67,7 +69,8 @@ public static CsDeclaration Create(Type type)
                                                       .ToArray()
                                                 : Array.Empty<string>(),
                            Members = type.GetDefinition()
-                                         .GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+                                         .GetMembers(BindingFlags.Public | BindingFlags.Instance |
+                                                     BindingFlags.DeclaredOnly)
                                          .Where(m => !typeof(object)
                                                       .GetMembers()
                                                       .Select(me => me.Name)
@@ -112,8 +115,9 @@ private static CsTypeMember Create(MemberInfo memberInfo)
                     return Create(methodInfo);
                 case PropertyInfo propertyInfo:
                     return Create(propertyInfo);
+                case FieldInfo fieldInfo:
+                    return Create(fieldInfo);
                 case TypeInfo _:
-                case FieldInfo _:
                 case EventInfo _:
                     return null;
                 default:
@@ -122,6 +126,50 @@ private static CsTypeMember Create(MemberInfo memberInfo)
             }
         }
 
+        private static CsTypeMember Create(FieldInfo fieldInfo)
+        {
+            CsLiteral? GetLiteral(Type fieldType)
+            {
+                if (!fieldInfo.IsLiteral)
+                {
+                    return null;
+                }
+
+                var constantValue = fieldInfo.GetRawConstantValue();
+
+                if (fieldType == typeof(string)
+                    || fieldType == typeof(int)
+                    || fieldType == typeof(bool)
+                    || fieldType.IsEnum)
+
+                {
+                    return new CsLiteral { Value = constantValue, Type = new CsType(fieldType) };
+                }
+
+                return null;
+            }
+
+            return new CsField
+                   {
+                       Name = fieldInfo.Name,
+                       IsStatic = fieldInfo.IsStatic,
+                       IsInherited = fieldInfo.DeclaringType != fieldInfo.ReflectedType,
+                       AccessModifier = GetAccessModifier(fieldInfo.IsPrivate,
+                                                          fieldInfo.IsFamily,
+                                                          fieldInfo.IsPublic,
+                                                          fieldInfo.IsAssembly),
+                       Attributes = fieldInfo.CustomAttributes
+                                             .Select(x => new CsAttribute
+                                                          {
+                                                              Name = x.AttributeType.Name,
+                                                              OriginalType = x.AttributeType
+                                                          })
+                                             .ToArray(),
+                       Type = new CsType(fieldInfo.FieldType),
+                       Value = GetLiteral(fieldInfo.FieldType)
+                   };
+        }
+
         private static CsMethod Create(MethodInfo methodInfo)
         {
             if (methodInfo.IsSpecialName)
diff --git a/src/LazyCoder/DependencyFinder.cs b/src/LazyCoder/DependencyFinder.cs
@@ -60,9 +60,13 @@ private static IEnumerable<TsType> Unwrap(TsType tsType)
                     return tsTypeReference.TypeArguments
                                           .SelectMany(Unwrap)
                                           .Append(tsTypeReference);
+                case TsEnumLiteralType tsEnumLiteralType:
+                    return new[] { tsEnumLiteralType.EnumType };
                 case TsNull _:
                 case TsPredefinedType _:
                 case TsStringLiteralType _:
+                case TsBoolLiteralType _:
+                case TsIntLiteralType _:
                     return new[]
                            {
                                tsType
diff --git a/src/LazyCoder/LazyCoder.csproj b/src/LazyCoder/LazyCoder.csproj
@@ -2,7 +2,8 @@
 
     <PropertyGroup>
         <TargetFramework>netstandard2.0</TargetFramework>
-        <LangVersion>7.3</LangVersion>
+        <LangVersion>8</LangVersion>
+        <Nullable>enable</Nullable>
     </PropertyGroup>
 
 </Project>
diff --git a/src/LazyCoder/Typescript/TsBoolLiteralType.cs b/src/LazyCoder/Typescript/TsBoolLiteralType.cs
@@ -0,0 +1,7 @@
+﻿namespace LazyCoder.Typescript
+{
+    public class TsBoolLiteralType: TsType
+    {
+        public bool Bool { get; set; }
+    }
+}
diff --git a/src/LazyCoder/Typescript/TsEnumLiteralType.cs b/src/LazyCoder/Typescript/TsEnumLiteralType.cs
@@ -0,0 +1,8 @@
+﻿namespace LazyCoder.Typescript
+{
+    public class TsEnumLiteralType: TsType
+    {
+        public string Value { get; set; }
+        public TsTypeReference EnumType { get; set; }
+    }
+}
diff --git a/src/LazyCoder/Typescript/TsIndexSignature.cs b/src/LazyCoder/Typescript/TsIndexSignature.cs
@@ -23,4 +23,4 @@ public static TsIndexSignature ByNumber(TsType valueType)
         public TsType IndexType { get; private set; }
         public TsType ValueType { get; private set; }
     }
-}
+}
diff --git a/src/LazyCoder/Typescript/TsIntLiteralType.cs b/src/LazyCoder/Typescript/TsIntLiteralType.cs
@@ -0,0 +1,7 @@
+﻿namespace LazyCoder.Typescript
+{
+    public class TsIntLiteralType: TsType
+    {
+        public int Int { get; set; }
+    }
+}
diff --git a/src/LazyCoder/Typescript/TsStringLiteralType.cs b/src/LazyCoder/Typescript/TsStringLiteralType.cs
@@ -4,4 +4,4 @@ public class TsStringLiteralType: TsType
     {
         public string String { get; set; }
     }
-}
+}
diff --git a/src/LazyCoder/Typescript/TsType.cs b/src/LazyCoder/Typescript/TsType.cs
@@ -14,10 +14,41 @@ public static TsType From(CsType csType,
             return From(csType.OriginalType, forceNullable);
         }
 
+        public static TsType FromLiteral(CsLiteral value)
+        {
+            if (value.Type.OriginalType.IsEnum)
+            {
+                return new TsEnumLiteralType
+                       {
+                           Value = Enum.GetName(value.Type.OriginalType, value.Value),
+                           EnumType = new TsTypeReference(value.Type.Name) { CsType = value.Type }
+                       };
+            }
+
+            if (value.Type.OriginalType == typeof(bool))
+            {
+                return new TsBoolLiteralType { Bool = (bool)value.Value };
+            }
+
+            if (value.Type.OriginalType == typeof(string))
+            {
+                return new TsStringLiteralType { String = (string)value.Value };
+            }
+
+            if (value.Type.OriginalType == typeof(int))
+            {
+                return new TsIntLiteralType { Int = (int)value.Value };
+            }
+
+            throw new ArgumentException("Not supported literal type " +
+                                        value.Type.OriginalType.Name);
+        }
+
         private static readonly List<ICustomTypeConverter> customTypeConverters =
             new List<ICustomTypeConverter>();
 
-        internal static void RegisterCustomTypeConverters(IEnumerable<ICustomTypeConverter> converters)
+        internal static void RegisterCustomTypeConverters(
+            IEnumerable<ICustomTypeConverter> converters)
         {
             customTypeConverters.AddRange(converters);
         }
diff --git a/src/LazyCoder/Writers/TsBoolLiteralWriter.cs b/src/LazyCoder/Writers/TsBoolLiteralWriter.cs
@@ -0,0 +1,12 @@
+﻿using LazyCoder.Typescript;
+
+namespace LazyCoder.Writers
+{
+    internal class TsBoolLiteralWriter: ITsWriter<TsBoolLiteralType>
+    {
+        public void Write(IKeyboard keyboard, TsBoolLiteralType tsBoolLiteralType)
+        {
+            keyboard.Write(tsBoolLiteralType.Bool);
+        }
+    }
+}
diff --git a/src/LazyCoder/Writers/TsBoolWriter.cs b/src/LazyCoder/Writers/TsBoolWriter.cs
@@ -0,0 +1,10 @@
+﻿namespace LazyCoder.Writers
+{
+    internal class TsBoolWriter: ITsWriter<bool>
+    {
+        public void Write(IKeyboard keyboard, bool value)
+        {
+            keyboard.Type(value.ToString().ToLowerInvariant());
+        }
+    }
+}
diff --git a/src/LazyCoder/Writers/TsEnumLiteralWriter.cs b/src/LazyCoder/Writers/TsEnumLiteralWriter.cs
@@ -0,0 +1,14 @@
+﻿using LazyCoder.Typescript;
+
+namespace LazyCoder.Writers
+{
+    internal class TsEnumLiteralWriter: ITsWriter<TsEnumLiteralType>
+    {
+        public void Write(IKeyboard keyboard, TsEnumLiteralType tsEnumLiteralType)
+        {
+            keyboard.Type(tsEnumLiteralType.EnumType.TypeName.Identifier)
+                    .Type(".")
+                    .Type(tsEnumLiteralType.Value);
+        }
+    }
+}
diff --git a/src/LazyCoder/Writers/TsIntLiteralWriter.cs b/src/LazyCoder/Writers/TsIntLiteralWriter.cs
@@ -0,0 +1,12 @@
+﻿using LazyCoder.Typescript;
+
+namespace LazyCoder.Writers
+{
+    internal class TsIntLiteralWriter: ITsWriter<TsIntLiteralType>
+    {
+        public void Write(IKeyboard keyboard, TsIntLiteralType tsIntLiteralType)
+        {
+            keyboard.Write(tsIntLiteralType.Int);
+        }
+    }
+}
diff --git a/src/LazyCoder/Writers/TsStringLiteralWriter.cs b/src/LazyCoder/Writers/TsStringLiteralWriter.cs
@@ -0,0 +1,12 @@
+﻿using LazyCoder.Typescript;
+
+namespace LazyCoder.Writers
+{
+    internal class TsStringLiteralWriter: ITsWriter<TsStringLiteralType>
+    {
+        public void Write(IKeyboard keyboard, TsStringLiteralType tsStringLiteralType)
+        {
+            keyboard.Write(tsStringLiteralType.String);
+        }
+    }
+}
diff --git a/tests/LazyCoder.Tests/LazyCoder.Tests.csproj b/tests/LazyCoder.Tests/LazyCoder.Tests.csproj
@@ -5,7 +5,9 @@
 
         <IsPackable>false</IsPackable>
 
-        <LangVersion>7.3</LangVersion>
+        <LangVersion>8</LangVersion>
+
+        <Nullable>enable</Nullable>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/tests/LazyCoder.Tests/Samples/Literals/Simple.cs b/tests/LazyCoder.Tests/Samples/Literals/Simple.cs
@@ -0,0 +1,51 @@
+﻿using System.Diagnostics.Contracts;
+using System.Linq;
+using Shouldly;
+using Xunit;
+
+namespace LazyCoder.Tests.Samples.Literals
+{
+    public class Simple
+    {
+        [Fact]
+        public void Test()
+        {
+            var tsFiles = Converter.Convert(
+                new[]
+                {
+                    typeof(SomeClass)
+                },
+                new[] { new DefaultCoder() });
+
+            tsFiles.Select(x => x.Name)
+                .ShouldBe(new[] { "SomeClass", "SomeEnum" },
+                    ignoreOrder: true);
+
+            Converter.WriteFileToString(tsFiles.Single(x => x.Name == "SomeClass"))
+                .ShouldBeLines("import { SomeEnum } from \"./SomeEnum\";",
+                    "",
+                    "export interface SomeClass {",
+                    "    EnumConst: SomeEnum.EnumValue2;",
+                    "    BoolConst: true;",
+                    "    StringConst: \"stringValue\";",
+                    "    IntConst: 42;",
+                    "}",
+                    "");
+        }
+
+        private class SomeClass
+        {
+            public const SomeEnum EnumConst = SomeEnum.EnumValue2;
+            public const bool BoolConst = true;
+            public const string StringConst = "stringValue";
+            public const int IntConst = 42;
+        }
+
+        private enum SomeEnum
+        {
+            EnumValue1,
+            EnumValue2
+        }
+
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,4 @@ public static TsIndexSignature ByNumber(TsType valueType)`
`23`	`23`	`public TsType IndexType { get; private set; }`
`24`	`24`	`public TsType ValueType { get; private set; }`
`25`	`25`	`}`
`26`		`-}`
	`26`	`+}`