Merge branch 'master' of https://github.com/neolithos/neolua

Author: neolithos

NeoLua.Test/Functions.cs

@@ -360,6 +360,64 @@ public void TestFunctions62()
 			}
 		}
 
+		[TestMethod]
+		public void TestForwardDeclaration()
+		{
+			TestCode(
+			@"local f
+			function f()
+				return 'Hello'
+			end
+
+			return f()",
+			"Hello");
+		}
+		[TestMethod]
+		public void TestDoubleLocalFunction()
+		{
+			TestCode(
+			@"local function f()
+				return 'Hello'
+			end
+			local function f()
+				return 'World'
+			end
+			return f()",
+			"World");
+		}
+
+		[TestMethod]
+		public void TestLocalMutualRecursiveFunction()
+		{
+			TestCode(
+			@"
+			local f1, f2
+			function f2()
+				return f1()
+			end
+			function f1()
+				return 'Hello'
+			end
+			return _G['f2'] == nil",
+			true);
+		}
+
+		[TestMethod]
+		public void TestAssignFunctionToParentLocal()
+		{
+			TestCode(@"
+local f
+function g()
+	function f()
+		return 'Hello'
+	end
+end
+g()
+return f()
+",
+"Hello");
+		}
+
 		[TestMethod]
 		public void TestFunctionConvert01()
 		{

NeoLua/Parser.cs

@@ -2180,10 +2180,19 @@ private static void ParseFunction(Scope scope, ILuaLexer code, bool isLocal)
 			if (isLocal) // Local function, only one identifier is allowed
 			{
 				var t = FetchToken(LuaToken.Identifier, code);
-				ParameterExpression funcVar = null;
-				var exprFunction = ParseLamdaDefinition(scope, code, t.Value, false,
-					typeDelegate => funcVar = scope.RegisterVariable(typeDelegate, t.Value)
-				);
+
+				ParameterExpression funcVar = scope.LookupExpression(t.Value) as ParameterExpression;
+				Expression exprFunction;
+				if (funcVar == null)
+				{
+					exprFunction = ParseLamdaDefinition(scope, code, t.Value, false,
+					typeDelegate => funcVar = scope.RegisterVariable(typeDelegate, t.Value));
+				}
+				else
+				{
+					exprFunction = ParseLamdaDefinition(scope, code, t.Value, false, null);
+				}
+					
 				scope.AddExpression(Expression.Assign(funcVar, exprFunction));
 			}
 			else // Function that is assigned to a table. A chain of identifiers is allowed.
@@ -2202,7 +2211,7 @@ private static void ParseFunction(Scope scope, ILuaLexer code, bool isLocal)
 					memberName = FetchToken(LuaToken.Identifier, code).Value;
 				}
 				// add a method to the table. methods get a hidden parameter and will bo marked
-				bool lMethodMember;
+				bool lMethodMember = false;
 				if (code.Current.Typ == LuaToken.Colon)
 				{
 					code.Next();
@@ -2216,8 +2225,17 @@ private static void ParseFunction(Scope scope, ILuaLexer code, bool isLocal)
 				else
 				{
 					if (assignee == null)
+					{
+						// there was no member access, so try to find a local to assign to
+						var local = scope.LookupExpression(memberName);
+						if (local is ParameterExpression)
+						{
+							scope.AddExpression(Expression.Assign(local, ParseLamdaDefinition(scope, code, memberName, false, null)));
+							return;
+						}
+
 						assignee = scope.LookupExpression(csEnv); // create a global function
-					lMethodMember = false;
+					}
 				}
 
 				// generate lambda
@@ -2295,7 +2313,7 @@ private static Expression ParseLamdaDefinition(Scope parent, ILuaLexer code, str
 			// register the delegate
 			if (functionTypeCollected != null)
 			{
-				var functionType = scope.ReturnType == typeof(void) 
+				var functionType = scope.ReturnType == typeof(void)
 					? Expression.GetActionType((from p in parameters select p.Type).ToArray())
 					: Expression.GetFuncType((from p in parameters select p.Type).Concat(new Type[] { scope.ReturnType }).ToArray());
 				functionTypeCollected(functionType);
@@ -2428,7 +2446,7 @@ private static void ParseTableField(ParameterExpression tableVar, Scope scope, I
 
 		private static Expression CreateEmptyTableExpression()
 			=> Expression.New(typeof(LuaTable));
-		
+
 		#endregion
 
 		#region -- FetchToken, ParseError ---------------------------------------------
@@ -2449,7 +2467,7 @@ public static Token FetchToken(LuaToken typ, ILuaLexer code, bool isOptional = f
 
 		public static LuaParseException ParseError(Token start, string message)
 			=> new LuaParseException(start.Start, message, null);
-		
+
 		private static Exception ParseError(ILuaLexer code, string message = null)
 		{
 			switch (code.Current.Typ)