remove VB support, cleanup ToType

Author: pwelter34

src/EntityFrameworkCore.Generator.Core/Extensions/GenerationExtensions.cs

@@ -1,11 +1,8 @@
-using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Text;
 
 using EntityFrameworkCore.Generator.Metadata.Generation;
 
-using static System.Net.Mime.MediaTypeNames;
-
 namespace EntityFrameworkCore.Generator.Extensions;
 
 public static class GenerationExtensions
@@ -24,52 +21,30 @@ public static class GenerationExtensions
         "__refvalue", "stackalloc"
     };
 
-    private static readonly HashSet<string> _visualBasicKeywords = new(StringComparer.OrdinalIgnoreCase)
-    {
-        "as", "do", "if", "in", "is", "me", "of", "on", "or", "to",
-        "and", "dim", "end", "for", "get", "let", "lib", "mod", "new", "not", "rem", "set", "sub", "try", "xor",
-        "ansi", "auto", "byte", "call", "case", "cdbl", "cdec", "char", "cint", "clng", "cobj", "csng", "cstr", "date", "each", "else",
-        "enum", "exit", "goto", "like", "long", "loop", "next", "step", "stop", "then", "true", "wend", "when", "with",
-        "alias", "byref", "byval", "catch", "cbool", "cbyte", "cchar", "cdate", "class", "const", "ctype", "cuint", "culng", "endif", "erase", "error",
-        "event", "false", "gosub", "isnot", "redim", "sbyte", "short", "throw", "ulong", "until", "using", "while",
-        "csbyte", "cshort", "double", "elseif", "friend", "global", "module", "mybase", "object", "option", "orelse", "public", "resume", "return", "select", "shared",
-        "single", "static", "string", "typeof", "ushort",
-        "andalso", "boolean", "cushort", "decimal", "declare", "default", "finally", "gettype", "handles", "imports", "integer", "myclass", "nothing", "partial", "private", "shadows",
-        "trycast", "unicode", "variant",
-        "assembly", "continue", "delegate", "function", "inherits", "operator", "optional", "preserve", "property", "readonly", "synclock", "uinteger", "widening",
-        "addressof", "interface", "namespace", "narrowing", "overloads", "overrides", "protected", "structure", "writeonly",
-        "addhandler", "directcast", "implements", "paramarray", "raiseevent", "withevents",
-        "mustinherit", "overridable",
-        "mustoverride",
-        "removehandler",
-        "class_finalize", "notinheritable", "notoverridable",
-        "class_initialize"
-    };
-
-    private static readonly List<string> _defaultUsings = new List<string>()
-    {
+    private static readonly HashSet<string> _defaultNamespaces =
+    [
+        "System",
         "System.Collections.Generic",
-        "System"
-    };
+    ];
 
-    private static readonly Dictionary<string, string> _csharpTypeAlias = new(16)
+    private static readonly Dictionary<Type, string> _csharpTypeAlias = new(16)
     {
-        {"System.Int16", "short"},
-        {"System.Int32", "int"},
-        {"System.Int64", "long"},
-        {"System.String", "string"},
-        {"System.Object", "object"},
-        {"System.Boolean", "bool"},
-        {"System.Void", "void"},
-        {"System.Char", "char"},
-        {"System.Byte", "byte"},
-        {"System.UInt16", "ushort"},
-        {"System.UInt32", "uint"},
-        {"System.UInt64", "ulong"},
-        {"System.SByte", "sbyte"},
-        {"System.Single", "float"},
-        {"System.Double", "double"},
-        {"System.Decimal", "decimal"}
+        { typeof(bool), "bool" },
+        { typeof(byte), "byte" },
+        { typeof(char), "char" },
+        { typeof(decimal), "decimal" },
+        { typeof(double), "double" },
+        { typeof(float), "float" },
+        { typeof(int), "int" },
+        { typeof(long), "long" },
+        { typeof(object), "object" },
+        { typeof(sbyte), "sbyte" },
+        { typeof(short), "short" },
+        { typeof(string), "string" },
+        { typeof(uint), "uint" },
+        { typeof(ulong), "ulong" },
+        { typeof(ushort), "ushort" },
+        { typeof(void), "void" }
     };
     #endregion
 
@@ -94,79 +69,44 @@ public static string MakeUnique(this string name, Func<string, bool> exists)
         return uniqueName;
     }
 
-    public static bool IsKeyword(this string text, CodeLanguage language = CodeLanguage.CSharp)
+    public static bool IsKeyword(this string text)
     {
         ArgumentException.ThrowIfNullOrEmpty(text);
 
-        return language == CodeLanguage.VisualBasic
-            ? _visualBasicKeywords.Contains(text)
-            : _csharpKeywords.Contains(text);
+        return _csharpKeywords.Contains(text);
     }
 
     [return: NotNullIfNotNull(nameof(name))]
-    public static string? ToSafeName(this string? name, CodeLanguage language = CodeLanguage.CSharp)
+    public static string? ToSafeName(this string? name)
     {
         if (string.IsNullOrEmpty(name))
             return name;
 
-        if (!name.IsKeyword(language))
+        if (!name.IsKeyword())
             return name;
 
-        return language == CodeLanguage.VisualBasic
-            ? string.Format("[{0}]", name)
-            : "@" + name;
+        return "@" + name;
     }
 
-    public static string ToType(this Type type, CodeLanguage language = CodeLanguage.CSharp)
+    public static string ToType(this Type type)
     {
         ArgumentNullException.ThrowIfNull(type);
 
-        if (type.IsGenericType)
-        {
-            var genericType = type.GetGenericTypeDefinition().FullName!
-                .Split('`')[0];     // trim the `1 bit
-
-            genericType = ToType(genericType, language);
-
-            var elementType = ToType(type.GetGenericArguments()[0].FullName!, language);
-            return language == CodeLanguage.VisualBasic
-                ? $"{genericType}(Of {elementType})"
-                : $"{genericType}<{elementType}>";
-        }
-
-        return ToType(type.FullName ?? type.Name, language);
+        var stringBuilder = new StringBuilder();
+        ProcessType(stringBuilder, type);
+        return stringBuilder.ToString();
     }
 
-    public static string ToType(this string type, CodeLanguage language = CodeLanguage.CSharp)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(type);
-
-        if (type == "System.Xml.XmlDocument")
-            type = "System.String";
-
-        if (language == CodeLanguage.CSharp && _csharpTypeAlias.TryGetValue(type, out var t))
-            return t;
-
-        // drop common namespaces
-        foreach (var defaultUsing in _defaultUsings)
-            if (type.StartsWith(defaultUsing))
-                return type.Remove(0, defaultUsing.Length + 1);
-
-        return type;
-    }
-
-    public static string? ToNullableType(this Type type, bool isNullable = false, CodeLanguage language = CodeLanguage.CSharp)
+    public static string? ToNullableType(this Type type, bool isNullable = false)
     {
         bool isValueType = type.IsValueType;
 
-        var typeString = type.ToType(language);
+        var typeString = type.ToType();
 
         if (!isValueType || !isNullable)
             return typeString;
 
-        return language == CodeLanguage.VisualBasic
-            ? $"Nullable(Of {type})"
-            : typeString + "?";
+        return typeString.EndsWith('?') ? typeString : typeString + "?";
     }
 
     public static bool IsValueType(this string? type)
@@ -189,4 +129,89 @@ public static string ToLiteral(this string value)
             ? "@\"" + value.Replace("\"", "\"\"") + "\""
             : "\"" + value.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
     }
+
+
+
+    private static void ProcessType(StringBuilder builder, Type type)
+    {
+        if (type.IsGenericType)
+        {
+            var genericArguments = type.GetGenericArguments();
+            ProcessGenericType(builder, type, genericArguments, genericArguments.Length);
+        }
+        else if (type.IsArray)
+        {
+            ProcessArrayType(builder, type);
+        }
+        else if (_csharpTypeAlias.TryGetValue(type, out var builtInName))
+        {
+            builder.Append(builtInName);
+        }
+        else if (type.Namespace.HasValue() && _defaultNamespaces.Contains(type.Namespace))
+        {
+            builder.Append(type.Name);
+        }
+        else
+        {
+            builder.Append(type.FullName ?? type.Name);
+        }
+    }
+
+    private static void ProcessArrayType(StringBuilder builder, Type type)
+    {
+        var innerType = type;
+        while (innerType.IsArray)
+        {
+            innerType = innerType.GetElementType()!;
+        }
+
+        ProcessType(builder, innerType);
+
+        while (type.IsArray)
+        {
+            builder.Append('[');
+            builder.Append(',', type.GetArrayRank() - 1);
+            builder.Append(']');
+            type = type.GetElementType()!;
+        }
+    }
+
+    private static void ProcessGenericType(StringBuilder builder, Type type, Type[] genericArguments, int length)
+    {
+        if (type.IsConstructedGenericType
+            && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+        {
+            ProcessType(builder, type.GetUnderlyingType());
+            builder.Append('?');
+            return;
+        }
+
+        var offset = type.DeclaringType != null ? type.DeclaringType.GetGenericArguments().Length : 0;
+        var genericPartIndex = type.Name.IndexOf('`');
+        if (genericPartIndex <= 0)
+        {
+            builder.Append(type.Name);
+            return;
+        }
+
+        builder.Append(type.Name, 0, genericPartIndex);
+        builder.Append('<');
+
+        for (var i = offset; i < length; i++)
+        {
+            ProcessType(builder, genericArguments[i]);
+            if (i + 1 == length)
+            {
+                continue;
+            }
+
+            builder.Append(',');
+            if (!genericArguments[i + 1].IsGenericParameter)
+            {
+                builder.Append(' ');
+            }
+        }
+
+        builder.Append('>');
+    }
 }

src/EntityFrameworkCore.Generator.Core/Extensions/TypeExtensions.cs

@@ -0,0 +1,34 @@
+namespace EntityFrameworkCore.Generator.Extensions;
+
+public static class TypeExtensions
+{
+    /// <summary>
+    /// Gets the underlying type dealing with <see cref="T:Nullable`1"/>.
+    /// </summary>
+    /// <param name="type">The type.</param>
+    /// <returns>Returns a type dealing with <see cref="T:Nullable`1"/>.</returns>
+    public static Type GetUnderlyingType(this Type type)
+    {
+        ArgumentNullException.ThrowIfNull(type);
+        return Nullable.GetUnderlyingType(type) ?? type;
+    }
+
+    /// <summary>
+    /// Determines whether the specified <paramref name="type"/> can be null.
+    /// </summary>
+    /// <param name="type">The type to check.</param>
+    /// <returns>
+    ///   <c>true</c> if the specified <paramref name="type"/> can be null; otherwise, <c>false</c>.
+    /// </returns>
+    public static bool IsNullable(this Type type)
+    {
+        ArgumentNullException.ThrowIfNull(type);
+
+        if (!type.IsGenericType || type.IsGenericTypeDefinition)
+            return false;
+
+        // Instantiated generic type only
+        Type genericType = type.GetGenericTypeDefinition();
+        return ReferenceEquals(genericType, typeof(Nullable<>));
+    }
+}

src/EntityFrameworkCore.Generator.Core/Metadata/Generation/CodeLanguage.cs

@@ -114,7 +114,7 @@ private static string ParseMethodName(InvocationExpressionSyntax node)
         return propertyName;
     }
 
-    private List<string> ParseLambdaExpressionForAnonymousObject(InvocationExpressionSyntax node)
+    private List<string>? ParseLambdaExpressionForAnonymousObject(InvocationExpressionSyntax node)
     {
         if (node == null)
             return null;
@@ -136,23 +136,21 @@ private List<string> ParseLambdaExpressionForAnonymousObject(InvocationExpressio
         if (anonymousObject == null)
             return null;
 
-        var propertyNames = anonymousObject
+        return anonymousObject
             .ChildNodes()
             .OfType<AnonymousObjectMemberDeclaratorSyntax>()
             .Select(declarator => declarator
                 .ChildNodes()
                 .OfType<MemberAccessExpressionSyntax>()
                 .FirstOrDefault())
-            .Where(memberAccess => memberAccess != null)
+            .OfType<MemberAccessExpressionSyntax>()
             .Select(memberAccess => memberAccess
                 .ChildNodes()
                 .OfType<IdentifierNameSyntax>()
                 .Select(identifier => identifier.Identifier.ValueText)
                 .LastOrDefault())
-            .Where(propertyName => propertyName != null)
+            .OfType<string>()
             .ToList();
-
-        return propertyNames;
     }
 
     private void ParseHasOne(InvocationExpressionSyntax node)
@@ -191,9 +189,9 @@ private void ParseForeignKey(InvocationExpressionSyntax node)
         if (node == null || ParsedEntity == null)
             return;
 
-        List<string> propertyNames = null;
+        List<string>? propertyNames = null;
         if (ParseLambaExpression(node) is string propertyName && !string.IsNullOrEmpty(propertyName))
-            propertyNames = new List<string> { propertyName };
+            propertyNames = [propertyName];
         else
             propertyNames = ParseLambdaExpressionForAnonymousObject(node);
 

src/EntityFrameworkCore.Generator.Core/Parsing/MappingVisitor.cs

@@ -227,7 +227,7 @@ private void GenerateRelationshipMapping(Relationship relationship)
         var primaryKeys = relationship.PrimaryProperties;
         var nonPrimaryPrincipalKey = !primaryKeys
             .Select(pp => relationship.PrimaryEntity.Properties.ByProperty(pp.PropertyName))
-            .All(p => p.IsPrimaryKey ?? true);
+            .All(p => p?.IsPrimaryKey ?? true);
 
         if (nonPrimaryPrincipalKey)
         {