added the working Type ToCode and logo!

Author: maximv

README.md

@@ -1,5 +1,7 @@
 # FastExpressionCompiler
 
+<img src="./logo.png" alt="logo"/>
+
 [DryIoc]: https://github.com/dadhi/DryIoc
 [ExpressionToCodeLib]: https://github.com/EamonNerbonne/ExpressionToCode
 [ExpressionTree]: https://msdn.microsoft.com/en-us/library/mt654263.aspx
@@ -263,3 +265,7 @@ expression at hand and may optimize for delegate with the closure or for "static
 
 Both optimizations are visible in benchmark results: search for `LightExpression` and 
 `FastCompiledLambdaWithPreCreatedClosure` respectively.
+
+
+---
+<a target="_blank" href="https://icons8.com/icons/set/bitten-ice-pop">Bitten Ice Pop icon</a> icon by <a target="_blank" href="https://icons8.com">Icons8</a>

logo.png

@@ -1488,69 +1488,155 @@ internal static StringBuilder AppendName<T>(this StringBuilder sb, string name,
                 : sb.Append(type.ToCode(true, null)).Append('_').Append(identity.GetHashCode());
 
         /// <summary>Converts the <paramref name="type"/> into the proper C# representation.</summary>
-        public static string ToCode(this Type type, bool stripNamespace = false, Func<Type, string, string> printType = null)
+        public static string ToCode(this Type type,
+            bool stripNamespace = false, Func<Type, string, string> printType = null, bool printGenericTypeArgs = false)
         {
+            if (type.IsGenericParameter)
+                return !printGenericTypeArgs ? string.Empty
+                    : (printType?.Invoke(type, type.Name) ?? type.Name);
+
+            Type arrayType = null;
+            if (type.IsArray)
+            {
+                // store the original type for the later and process its element type further here
+                arrayType = type;
+                type = type.GetElementType();
+            }
+
             // the default handling of the built-in types
+            string buildInTypeString = null;
             if (type == typeof(void))
-                return "void";
+                buildInTypeString = "void";
             if (type == typeof(object))
-                return "object";
+                buildInTypeString = "object";
             if (type == typeof(bool))
-                return "bool";
+                buildInTypeString = "bool";
             if (type == typeof(int))
-                return "int";
+                buildInTypeString = "int";
             if (type == typeof(short))
-                return "short";
+                buildInTypeString = "short";
             if (type == typeof(byte))
-                return "byte";
+                buildInTypeString = "byte";
             if (type == typeof(double))
-                return "double";
+                buildInTypeString = "double";
             if (type == typeof(float))
-                return "float";
+                buildInTypeString = "float";
             if (type == typeof(char))
-                return "char";
+                buildInTypeString = "char";
             if (type == typeof(string))
-                return "string";
+                buildInTypeString = "string";
 
-            var isArray = type.IsArray;
-            if (isArray)
-                type = type.GetElementType();
+            if (buildInTypeString != null)
+                return printType?.Invoke(arrayType ?? type, buildInTypeString) ?? buildInTypeString;
 
-            var typeString = stripNamespace ? type.Name : type.FullName ?? type.Name;
+            var parentCount = 0;
+            for (var ti = type.GetTypeInfo(); ti.IsNested; ti = ti.DeclaringType.GetTypeInfo())
+                ++parentCount;
 
-            typeString = typeString.Replace('+', '.'); // handling the nested types
+            Type[] parentTypes = null;
+            if (parentCount > 0) 
+            {
+                parentTypes = new Type[parentCount];
+                var pt = type.DeclaringType;
+                for (var i = 0; i < parentTypes.Length; i++, pt = pt.DeclaringType)
+                    parentTypes[i] = pt;
+            }
 
             var typeInfo = type.GetTypeInfo();
-            if (!typeInfo.IsGenericType)
+            Type[] typeArgs = null;
+            var isTypeClosedGeneric = false;
+            if (type.IsGenericType)
             {
-                if (printType != null)
-                    typeString = printType.Invoke(type, typeString);
-                return isArray ? typeString + "[]" : typeString;
+                isTypeClosedGeneric = !typeInfo.IsGenericTypeDefinition;
+                typeArgs = isTypeClosedGeneric ? typeInfo.GenericTypeArguments : typeInfo.GenericTypeParameters;
             }
 
+            var typeArgsConsumedByParentsCount = 0;
             var s = new StringBuilder();
-            var tickIndex = typeString.IndexOf('`');
-            if (tickIndex == -1) 
-                s.Append(typeString);
-            else 
-                s.Append(typeString.Substring(0, tickIndex));
-            
-            s.Append('<'); // todo: handling the generics in the nested type
+            if (!stripNamespace) 
+                s.Append(type.Namespace).Append('.');
 
-            var genericArgs = typeInfo.GetGenericTypeParametersOrArguments();
-            if (typeInfo.IsGenericTypeDefinition)
-                s.Append(',', genericArgs.Length - 1);
-            else
-                for (var i = 0; i < genericArgs.Length; i++)
-                    (i > 0 ? s.Append(", ") : s).Append(genericArgs[i].ToCode(stripNamespace, printType));
+            if (parentTypes != null) 
+            {
+                for (var p = parentTypes.Length - 1; p >= 0; --p)
+                {
+                    var parentType = parentTypes[p];
+                    var parentTypeInfo = parentType.GetTypeInfo();
 
-            s.Append('>');
+                    if (!parentType.IsGenericType)
+                    {
+                        s.Append(parentType.Name).Append('.');
+                    }
+                    else
+                    {
+                        Type[] parentTypeArgs = null;
+                        if (parentTypeInfo.IsGenericTypeDefinition)
+                        {
+                            parentTypeArgs = parentTypeInfo.GenericTypeParameters;
+
+                            // replace the open parent args with the closed child args,
+                            // and close the parent
+                            if (isTypeClosedGeneric)
+                                for (var t = 0; t < parentTypeArgs.Length; ++t) 
+                                    parentTypeArgs[t] = typeArgs[t];
+
+                            var parentTypeArgCount = parentTypeArgs.Length;
+                            if (typeArgsConsumedByParentsCount > 0)
+                            {
+                                int ownArgCount = parentTypeArgCount - typeArgsConsumedByParentsCount;
+                                if (ownArgCount == 0)
+                                    parentTypeArgs = null;
+                                else
+                                {
+                                    var ownArgs = new Type[ownArgCount];
+                                    for (var a = 0; a < ownArgs.Length; ++a)
+                                        ownArgs[a] = parentTypeArgs[a + typeArgsConsumedByParentsCount];
+                                    parentTypeArgs = ownArgs;
+                                }
+                            }
+                            typeArgsConsumedByParentsCount = parentTypeArgCount;
+                        }
+                        else 
+                        {
+                            parentTypeArgs = parentTypeInfo.GenericTypeArguments;
+                        }
+
+                        var parentTickIndex = parentType.Name.IndexOf('`');
+                        s.Append(parentType.Name.Substring(0, parentTickIndex));
+
+                        // The owned parentTypeArgs maybe empty because all args are defined in the parent's parents
+                        if (parentTypeArgs?.Length > 0)
+                        {
+                            s.Append('<');
+                            for (var t = 0; t < parentTypeArgs.Length; ++t)
+                                (t == 0 ? s : s.Append(", "))
+                                    .Append(parentTypeArgs[t].ToCode(stripNamespace, printType, printGenericTypeArgs));
+                            s.Append('>');
+                        }
+                        s.Append('.');
+                    }
+                }
+            }
+
+            if (typeArgs != null && typeArgsConsumedByParentsCount < typeArgs.Length)
+            {
+                var tickIndex = type.Name.IndexOf('`');
+                s.Append(type.Name.Substring(0, tickIndex)).Append('<');
+                for (var i = 0; i < typeArgs.Length - typeArgsConsumedByParentsCount; ++i) 
+                    (i == 0 ? s : s.Append(", "))
+                        .Append(typeArgs[i + typeArgsConsumedByParentsCount]
+                            .ToCode(stripNamespace, printType, printGenericTypeArgs));
+                s.Append('>');
+            }
+            else
+            {
+                s.Append(type.Name);
+            }
 
-            if (isArray)
+            if (arrayType != null)
                 s.Append("[]");
 
-            typeString = s.ToString();
-            return printType?.Invoke(type, typeString) ?? typeString;
+            return printType?.Invoke(arrayType ?? type, s.ToString()) ?? s.ToString();
         }
 
         /// Prints valid C# Boolean

src/FastExpressionCompiler.LightExpression/Expression.cs

@@ -2623,7 +2623,6 @@ private static bool TryEmitNotNullConstant(
                     if (constIndex == -1)
                         return false;
 
-                    // todo: @incomplete - are we still using the usage to decide for the vars?
                     var varIndex = closure.ConstantUsageThenVarIndex.Items[constIndex] - 1;
                     if (varIndex > 0)
                         EmitLoadLocalVariable(il, varIndex);
@@ -3737,13 +3736,17 @@ private static bool TryEmitNestedLambda(LambdaExpression lambdaExpr,
             private static bool TryEmitInvoke(InvocationExpression expr,
                 IReadOnlyList<ParameterExpression> paramExprs, ILGenerator il, ref ClosureInfo closure, ParentFlags parent)
             {
-                var lambda = expr.Expression; // todo: @perf check if that a Constant or LambdaExpression and call the their emit methods directly
-                var delegateInvokeMethod = lambda.Type.FindDelegateInvokeMethod();
-             
+                var lambda = expr.Expression;
                 var useResult = parent & ~ParentFlags.IgnoreResult;
+
+                // if (lambda is ConstantExpression cl) {
+                //     // todo: @perf call directly
+                // }
                 if (!TryEmit(lambda, paramExprs, il, ref closure, useResult))
                     return false;
 
+                var delegateInvokeMethod = lambda.Type.FindDelegateInvokeMethod();
+
 #if LIGHT_EXPRESSION
                 if (expr is OneArgumentInvocationExpression oneArgExpr) 
                 {

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -18,11 +18,87 @@ public class IssueXXX_Loop_wih_conditions_fails : ITest
     {
         public int Run()
         {
-            Test1();
-            return 1;
+#if LIGHT_EXPRESSION
+            Test_nested_generic_type_output();
+            Test_triple_nested_non_generic();
+            Test_triple_nested_open_generic();
+            Test_non_generic_classes();
+#endif
+            // Test1();
+            return 4;
+        }
+
+
+#if LIGHT_EXPRESSION
+        [Test]
+        public void Test_nested_generic_type_output() 
+        {
+            var s = typeof(ReadMethods<Test[], BufferedStream, Settings_1449479367_b6fc048b>.ReadSealed)
+                .ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""));
+
+            Assert.AreEqual("ReadMethods<Test[], BufferedStream, Settings_1449479367_b6fc048b>.ReadSealed", s);
+        }
+
+        [Test]
+        public void Test_triple_nested_non_generic() 
+        {
+            var s = typeof(A<int>.B<string>.Z).ToCode(true);
+            Assert.AreEqual("IssueXXX_Loop_wih_conditions_fails.A<int>.B<string>.Z", s);
+
+            s = typeof(A<int>.B<string>.Z).ToCode();
+            Assert.AreEqual("FastExpressionCompiler.LightExpression.IssueTests.IssueXXX_Loop_wih_conditions_fails.A<int>.B<string>.Z", s);
+
+            s = typeof(A<int>.B<string>.Z[]).ToCode(true);
+            Assert.AreEqual("IssueXXX_Loop_wih_conditions_fails.A<int>.B<string>.Z[]", s);
+            
+            s = typeof(A<int>.B<string>.Z[]).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""));
+            Assert.AreEqual("A<int>.B<string>.Z[]", s);
+        }
+
+        [Test]
+        public void Test_triple_nested_open_generic() 
+        {
+            var s = typeof(A<>).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""));
+            Assert.AreEqual("A<>", s);
+            
+            s = typeof(A<>).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""), true);
+            Assert.AreEqual("A<X>", s);
+
+            s = typeof(A<>.B<>).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""));
+            Assert.AreEqual("A<>.B<>", s);
+
+            s = typeof(A<>.B<>.Z).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""));
+            Assert.AreEqual("A<>.B<>.Z", s);
+
+            s = typeof(A<>.B<>.Z).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""), true);
+            Assert.AreEqual("A<X>.B<Y>.Z", s);
         }
 
         [Test]
+        public void Test_non_generic_classes() 
+        {
+            var s = typeof(A.B.C).ToCode(true, (_, x) => x.Replace("IssueXXX_Loop_wih_conditions_fails.", ""));
+            Assert.AreEqual("A.B.C", s);
+        }
+
+        class A
+        {
+            public class B
+            {
+                public class C {}
+            }
+        }
+
+        class A<X> 
+        {
+            public class B<Y> 
+            {
+                public class Z {}
+            }
+        }
+
+#endif
+        // [Test]
         public void Test1()
         {
     //         var e = new Expression[63]; // unique expressions
@@ -46,7 +122,7 @@ public void Test1()
     //               e[8] = MakeBinary(ExpressionType.Assign,
     //                 e[4]/*Parameter*/,
     //                 e[9] = Call(
-    //                   e[6]/*Parameter*/,
+    //                   e[6]/*Parameter*/
     //                   typeof(BufferedStream)/*.Read*/.GetMethods()[10].MakeGenericMethod(typeof(int)))),
     //               e[10] = MakeBinary(ExpressionType.Assign,
     //                 e[1]/*Parameter*/,

test/FastExpressionCompiler.IssueTests/IssueXXX_Loop_wih_conditions_fails.cs

@@ -10,7 +10,8 @@ public class Program
         public static void Main()
         {
             RunAllTests();
-            // new Issue156_InvokeAction().Run();
+
+            // new FastExpressionCompiler.LightExpression.IssueTests.IssueXXX_Loop_wih_conditions_fails().Run();
             // new FastExpressionCompiler.LightExpression.IssueTests.Issue156_InvokeAction().Run();
             // new FastExpressionCompiler.LightExpression.IssueTests.Issue215_Assign_to_member_test().Run();
             // new FastExpressionCompiler.LightExpression.IssueTests.Issue237_Trying_to_implement_For_Foreach_loop_but_getting_an_InvalidProgramException_thrown().Run();