Enumerator based coroutine yielding

src/MoonSharp.Interpreter/CoreLib/CoroutineModule.cs

@@ -121,7 +121,18 @@ public static DynValue status(ScriptExecutionContext executionContext, CallbackA
 			}
 
 		}
-
+
+		[MoonSharpModuleMethod]
+		public static DynValue is_return_value(ScriptExecutionContext executionContext, CallbackArguments args)
+		{
+			return args[0].Type == DataType.ClrCoroutineReturn ? DynValue.True : DynValue.False;
+		}
+
+		[MoonSharpModuleMethod]
+		public static DynValue get_return_value(ScriptExecutionContext executionContext, CallbackArguments args)
+		{
+			return args[0].Type == DataType.ClrCoroutineReturn ? args[0].ClrCoroutineReturnValue : DynValue.Nil;
+		}
 
 	}
 }

src/MoonSharp.Interpreter/DataTypes/DataType.cs

@@ -64,6 +64,10 @@ public enum DataType
 		/// A request to coroutine.yield
 		/// </summary>
 		YieldRequest,
+		/// <summary>
+		/// Return a value from a clr coroutine
+		/// </summary>
+		ClrCoroutineReturn,
 	}
 
 	/// <summary>
@@ -114,6 +118,8 @@ public static string ToErrorTypeString(this DataType type)
 					return "userdata";
 				case DataType.Thread:
 					return "coroutine";
+				case DataType.ClrCoroutineReturn:
+					return "coroutine_return";
 				case DataType.Tuple:
 				case DataType.TailCallRequest:
 				case DataType.YieldRequest:
@@ -164,6 +170,8 @@ public static string ToLuaTypeString(this DataType type)
 					return "userdata";
 				case DataType.Thread:
 					return "thread";
+				case DataType.ClrCoroutineReturn:
+					return "coroutine_return";
 				case DataType.Tuple:
 				case DataType.TailCallRequest:
 				case DataType.YieldRequest:

src/MoonSharp.Interpreter/DataTypes/DynValue.cs

@@ -76,6 +76,11 @@ public sealed class DynValue
 		/// Gets the tail call data.
 		/// </summary>
 		public UserData UserData { get { return m_Object as UserData; } }
+
+		/// <summary>
+		/// Gets the clr couroutine return value
+		/// </summary>
+		public DynValue ClrCoroutineReturnValue { get { return m_Object as DynValue; } }
 
 		/// <summary>
 		/// Returns true if this instance is write protected.
@@ -373,6 +378,14 @@ public static DynValue NewUserData(UserData userData)
 			};
 		}
 
+		public static DynValue NewClrCoroutineReturn(DynValue returnedValue) {
+			return new DynValue()
+			{
+				m_Object = returnedValue,
+				m_Type = DataType.ClrCoroutineReturn,
+			};
+		}
+
 		/// <summary>
 		/// Returns this value as readonly - eventually cloning it in the process if it isn't readonly to start with.
 		/// </summary>

src/MoonSharp.Interpreter/Interop/Attributes/MoonSharpClrCoroutineAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace MoonSharp.Interpreter
+{
+    /// <summary>
+    /// Marks a method as a clr enumerator based coroutine
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, Inherited = true)]
+    public sealed class MoonSharpClrCoroutineAttribute : Attribute
+	{
+        public MoonSharpClrCoroutineAttribute()
+		{
+        }
+    }
+}

src/MoonSharp.Interpreter/Interop/BasicDescriptors/DispatchingUserDataDescriptor.cs

@@ -178,7 +178,7 @@ private void AddMemberTo(Dictionary<string, IMemberDescriptor> members, string n
 		{
 			IOverloadableMemberDescriptor odesc = desc as IOverloadableMemberDescriptor;
 
-			if (odesc != null)
+			if (odesc != null && !(desc is MethodMemberDescriptorCoroutine))
 			{
 				if (members.ContainsKey(name))
 				{

src/MoonSharp.Interpreter/Interop/StandardDescriptors/ReflectionMemberDescriptors/MethodMemberDescriptorCoroutine.cs

@@ -0,0 +1,48 @@
+using System.Reflection;
+
+namespace MoonSharp.Interpreter.Interop 
+{
+    public class MethodMemberDescriptorCoroutine : MethodMemberDescriptor 
+	{
+        public MethodMemberDescriptorCoroutine(MethodBase methodBase, InteropAccessMode accessMode = InteropAccessMode.Default) : base(methodBase, accessMode) 
+		{
+        }
+
+        public override DynValue GetValue(Script script, object obj) 
+		{
+            var enumerateYielder = script.DoString(@"return function (callable) 
+    return function (...)
+        for y in callable(...) do
+            if coroutine.is_return_value(y) then
+                return coroutine.get_return_value(y)
+            else 
+                coroutine.yield(y)
+            end
+        end
+    end
+end", null, MethodInfo + "_yielder");
+            return script.Call(enumerateYielder, base.GetValue(script, obj));
+        }
+
+        /// Tries to create a new MethodMemberDescriptorCoroutine, returning 
+        /// <c>null</c> in case the method is not
+        /// visible to script code.
+        /// </summary>
+        /// <param name="methodBase">The MethodBase.</param>
+        /// <param name="accessMode">The <see cref="InteropAccessMode" /></param>
+        /// <param name="forceVisibility">if set to <c>true</c> forces visibility.</param>
+        /// <returns>
+        /// A new MethodMemberDescriptor or null.
+        /// </returns>
+        public static MethodMemberDescriptorCoroutine TryCreateCoroutineIfVisible(MethodBase methodBase, InteropAccessMode accessMode, bool forceVisibility = false)
+        {
+            if (!CheckMethodIsCompatible(methodBase, false))
+                return null;
+
+            if (forceVisibility || (methodBase.GetVisibilityFromAttributes() ?? methodBase.IsPublic))
+                return new MethodMemberDescriptorCoroutine(methodBase, accessMode);
+
+            return null;
+        }
+    }
+}

src/MoonSharp.Interpreter/Interop/StandardDescriptors/StandardUserDataDescriptor.cs

@@ -78,7 +78,12 @@ private void FillMemberList()
 			{
 				if (membersToIgnore.Contains(mi.Name)) continue;
 
-				MethodMemberDescriptor md = MethodMemberDescriptor.TryCreateIfVisible(mi, this.AccessMode);
+				MethodMemberDescriptor md;
+				if (mi.CustomAttributes.Any(data => data.AttributeType == typeof(MoonSharpClrCoroutineAttribute))) {
+					md = MethodMemberDescriptorCoroutine.TryCreateCoroutineIfVisible(mi, this.AccessMode);
+				} else {
+					md = MethodMemberDescriptor.TryCreateIfVisible(mi, this.AccessMode);
+				}
 
 				if (md != null)
 				{