Better generic types management in progress

Author: codingseb

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -867,6 +867,7 @@ public void TypeTesting(string expression, Type type)
         #region Generic types Management
 
         [TestCase("List(\"Hello\", \"Test\").Cast<string>().ToList<string>().GetType()", ExpectedResult = typeof(List<string>) , Category = "List function, Generics")]
+        [TestCase("new List<string>().GetType()", ExpectedResult = typeof(List<string>) , Category = "List function, Generics")]
 
         #endregion
 

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -1416,7 +1416,8 @@ private bool EvaluateInstanceCreationWithNewKeyword(string expr, string restOfEx
                 || stack.Peek() is ExpressionOperator))
             {
                 string completeName = instanceCreationMatch.Groups["name"].Value;
-                Type type = GetTypeByFriendlyName(completeName);
+                string genericTypes = instanceCreationMatch.Groups["isgeneric"].Value;
+                Type type = GetTypeByFriendlyName(completeName, genericTypes);
 
                 i += instanceCreationMatch.Length;
 
@@ -1839,8 +1840,9 @@ private bool EvaluateVarOrFunc(string expr, string restOfExpression, Stack<objec
                                         !typeName.EndsWith("?"))
                                     {
                                         subIndex += namespaceMatch.Length;
-                                        typeName += $"{namespaceMatch.Value}{((i + subIndex < expr.Length && expr.Substring(i + subIndex)[0] == '?') ? "?" : "") }";
-                                        staticType = GetTypeByFriendlyName(typeName);
+                                        typeName += $".{namespaceMatch.Groups["name"].Value}{((i + subIndex < expr.Length && expr.Substring(i + subIndex)[0] == '?') ? "?" : "") }";
+
+                                        staticType = GetTypeByFriendlyName(typeName, namespaceMatch.Groups["isgeneric"].Value);
 
                                         if(staticType != null)
                                         {
@@ -2658,12 +2660,20 @@ private bool DefaultFunctions(string name, List<string> args, out object result)
             return functionExists;
         }
 
-        private Type GetTypeByFriendlyName(string typeName)
+        private Type GetTypeByFriendlyName(string typeName, string genericTypes = "")
         {
             Type result = null;
             try
             {
-                result = Type.GetType(typeName, false, !OptionCaseSensitiveEvaluationActive);
+                string formatedGenericTypes = string.Empty;
+
+                if (!genericTypes.Equals(string.Empty))
+                {
+                    Type[] types = GetConcreteTypes(genericTypes);
+                    formatedGenericTypes = $"`{types.Length}[{ string.Join(", ", types.Select(type => type.FullName))}]";
+                }
+
+                result = Type.GetType(typeName + formatedGenericTypes, false, !OptionCaseSensitiveEvaluationActive);
 
                 if (result == null)
                 {
@@ -2683,12 +2693,12 @@ private Type GetTypeByFriendlyName(string typeName)
                 for (int a = 0; a < Assemblies.Count && result == null; a++)
                 {
                     if(typeName.Contains("."))
-                        result = Type.GetType($"{typeName},{Assemblies[a].FullName}", false, !OptionCaseSensitiveEvaluationActive);
+                        result = Type.GetType($"{typeName}{formatedGenericTypes},{Assemblies[a].FullName}", false, !OptionCaseSensitiveEvaluationActive);
                     else
                     {
                         for (int i = 0; i < Namespaces.Count && result == null; i++)
                         {
-                            result = Type.GetType($"{Namespaces[i]}.{typeName},{Assemblies[a].FullName}", false, !OptionCaseSensitiveEvaluationActive);
+                            result = Type.GetType($"{Namespaces[i]}.{typeName}{formatedGenericTypes},{Assemblies[a].FullName}", false, !OptionCaseSensitiveEvaluationActive);
                         }
                     }
                 }