IsExpression

Author: chaowlert

ExpressionDebugger.Tests/DebugInfoInjectorTest.cs

@@ -674,5 +674,24 @@ public static int Main()
 }"
                 , str);
         }
+
+        [TestMethod]
+        public void TestExpression()
+        {
+            Expression<Func<Data, Data>> lambda = data => new Data {Id = data.Id + "1", Records = data.Records.Select(it => it + 1)};
+            var str = lambda.ToScript(new ExpressionDefinitions {IsExpression = true});
+            Assert.AreEqual(@"
+public Expression<Func<DebugInfoInjectorTest.Data, DebugInfoInjectorTest.Data>> Main = data => new DebugInfoInjectorTest.Data()
+{
+    Id = data.Id + ""1"",
+    Records = data.Records.Select<int, int>(it => it + 1)
+};", str);
+        }
+
+        public class Data
+        {
+            public string Id { get; set; }
+            public IEnumerable<int> Records { get; set; }
+        }
     }
 }

ExpressionTranslator/ExpressionDefinitions.cs

@@ -10,5 +10,6 @@ public class ExpressionDefinitions
         public bool IsStatic { get; set; }
         public string MethodName { get; set; }
         public IEnumerable<Type> Implements { get; set; }
+        public bool IsExpression { get; set; }
     }
 }

ExpressionTranslator/ExpressionTranslator.cs

@@ -1117,44 +1117,58 @@ private void WriteModifier(bool isPublic)
 
         private Expression VisitLambda(LambdaExpression node, LambdaType type)
         {
-            if (type == LambdaType.Function || type == LambdaType.Main)
-            {
-                var name = type == LambdaType.Main
-                    ? (Definitions?.MethodName ?? "Main")
-                    : GetName(node);
-                WriteModifier(type == LambdaType.Main);
-                Write(Translate(node.ReturnType), " ", name);
-                var args = VisitArguments("(", node.Parameters, VisitParameterDeclaration, ")");
-                Indent();
-                var body = VisitBody(node.Body, true);
-
-                Outdent();
-
-                return Expression.Lambda(body, name, node.TailCall, args);
-            }
-            else
+            if (type == LambdaType.Inline || this.Definitions?.IsExpression == true)
             {
+                if (type == LambdaType.Main)
+                {
+                    var name = Definitions?.MethodName ?? "Main";
+                    WriteModifier(true);
+                    var funcType = MakeDelegateType(node.ReturnType, node.Parameters.Select(it => it.Type).ToArray());
+                    var exprType = typeof(Expression<>).MakeGenericType(funcType);
+                    Write(Translate(exprType), " ", name, " = ");
+                }
                 IList<ParameterExpression> args;
                 if (node.Parameters.Count == 1)
                 {
                     args = new List<ParameterExpression>();
                     var arg = VisitParameter(node.Parameters[0]);
-                    args.Add((ParameterExpression)arg);
+                    args.Add((ParameterExpression) arg);
                 }
                 else
                 {
-                    args = VisitArguments("(", node.Parameters.ToList(), p => (ParameterExpression)VisitParameter(p), ")");
+                    args = VisitArguments("(", node.Parameters.ToList(), p => (ParameterExpression) VisitParameter(p),")");
                 }
+
                 Write(" => ");
                 var body = VisitGroup(node.Body, ExpressionType.Quote);
+                if (type == LambdaType.Main)
+                    Write(";");
                 return Expression.Lambda(body, node.Name, node.TailCall, args);
             }
+            else
+            {
+                var name = type == LambdaType.Main
+                    ? (Definitions?.MethodName ?? "Main")
+                    : GetName(node);
+                WriteModifier(type == LambdaType.Main);
+                Write(Translate(node.ReturnType), " ", name);
+                var args = VisitArguments("(", node.Parameters, VisitParameterDeclaration, ")");
+                Indent();
+                var body = VisitBody(node.Body, true);
+
+                Outdent();
+
+                return Expression.Lambda(body, name, node.TailCall, args);
+            }
         }
 
         private HashSet<LambdaExpression> _visitedLambda;
         private int _writerLevel;
         protected override Expression VisitLambda<T>(Expression<T> node)
         {
+            if (this.Definitions?.IsExpression == true)
+                return VisitLambda(node, LambdaType.Function);
+
             Write(GetName(node));
 
             if (_visitedLambda == null)
@@ -1282,14 +1296,25 @@ protected override MemberMemberBinding VisitMemberMemberBinding(MemberMemberBind
             return node.Update(args);
         }
 
-        private static Type GetDelegateType(MethodInfo method)
+        private static Type MakeDelegateType(Type returnType, params Type[] parameters)
         {
-            if (method.GetParameters().Any(it => it.IsOut || it.ParameterType.IsByRef))
-                throw new InvalidOperationException("Cannot handle non-public method");
+            var del = GetDelegateType(returnType != typeof(void), parameters.Length);
+            if (del.GetTypeInfo().IsGenericTypeDefinition)
+            {
+                var types = parameters.AsEnumerable();
+                if (returnType != typeof(void))
+                    types = types.Concat(new[] { returnType });
+                del = del.MakeGenericType(types.ToArray());
+            }
 
-            if (method.ReturnType == typeof(void))
+            return del;
+        }
+
+        private static Type GetDelegateType(bool isFunc, int argCount)
+        {
+            if (!isFunc)
             {
-                switch (method.GetParameters().Length)
+                switch (argCount)
                 {
                     case 0: return typeof(Action);
                     case 1: return typeof(Action<>);
@@ -1313,7 +1338,7 @@ private static Type GetDelegateType(MethodInfo method)
             }
             else
             {
-                switch (method.GetParameters().Length)
+                switch (argCount)
                 {
                     case 0: return typeof(Func<>);
                     case 1: return typeof(Func<,>);
@@ -1352,14 +1377,10 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
             else if (!node.Method.IsPublic || node.Method.DeclaringType?.GetTypeInfo().IsNotPublic == true)
             {
                 isNotPublic = true;
-                var del = GetDelegateType(node.Method);
-                if (del.GetTypeInfo().IsGenericTypeDefinition)
-                {
-                    var types = node.Method.GetParameters().Select(it => it.ParameterType);
-                    if (node.Method.ReturnType != typeof(void))
-                        types = types.Concat(new[] { node.Method.ReturnType });
-                    del = del.MakeGenericType(types.ToArray());
-                }
+                if (node.Method.GetParameters().Any(it => it.IsOut || it.ParameterType.IsByRef))
+                    throw new InvalidOperationException("Cannot handle non-public method");
+
+                var del = MakeDelegateType(node.Method.ReturnType, node.Method.GetParameters().Select(it => it.ParameterType).ToArray());
                 var func = node.Method.CreateDelegate(del);
                 Write(GetConstant(func, GetVarName(node.Method.Name)), ".Invoke");
             }