Merge pull request #19 from Librelancer/feat-hoisting

Feature: Hoisting

Author: CallumDev

src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScope.cs

@@ -103,6 +103,14 @@ public SymbolRef TryDefineLocal(string name)
 			return m_Frames.Last().TryDefineLocal(name);
 		}
 
+		public void BlockResolution(IEnumerable<SymbolRef> locals)
+		{
+			m_Frames.Last().BlockResolution(locals);
+		}
+		
+		public void UnblockResolution() => m_Frames.Last().UnblockResolution();
+
+
 		public bool CurrentFunctionHasVarArgs()
 		{
 			return m_Frames.Last().HasVarArgs;

src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeBlock.cs

@@ -34,8 +34,25 @@ internal BuildTimeScopeBlock AddChild()
 			return block;
 		}
 
+		private HashSet<string> blockedNames = new HashSet<string>();
+		internal void BlockResolution(IEnumerable<SymbolRef> locals)
+		{
+			foreach(var l in locals) {
+				if (!m_DefinedNames.ContainsValue(l))
+					throw new InternalErrorException("Tried to block resolution of local outside of block");
+				blockedNames.Add(l.Name);
+			}
+		}
+
+		internal void UnblockResolution()
+		{
+			blockedNames.Clear();
+		}
+		
+
 		internal SymbolRef Find(string name)
 		{
+			if (blockedNames.Contains(name)) return null;
 			return m_DefinedNames.GetOrDefault(name);
 		}
 

src/MoonSharp.Interpreter/Execution/Scopes/BuildTimeScopeFrame.cs

@@ -64,6 +64,13 @@ internal SymbolRef DefineLocal(string name)
 			return m_ScopeTreeHead.Define(name);
 		}
 
+		internal void BlockResolution(IEnumerable<SymbolRef> locals)
+		{
+			m_ScopeTreeHead.BlockResolution(locals);
+		}
+
+		internal void UnblockResolution() => m_ScopeTreeHead.UnblockResolution();
+
 		internal SymbolRef TryDefineLocal(string name)
 		{
 			if (m_ScopeTreeHead.Find(name) != null)

src/MoonSharp.Interpreter/Tree/Expression_.cs

@@ -22,6 +22,8 @@ public virtual string GetFriendlyDebugName()
 
 		public abstract DynValue Eval(ScriptExecutionContext context);
 
+		public abstract void ResolveScope(ScriptLoadingContext lcontext);
+
 		public abstract bool EvalLiteral(out DynValue dv);
 
 		public void CompilePossibleLiteral(ByteCode bc)

src/MoonSharp.Interpreter/Tree/Expressions/AdjustmentExpression.cs

@@ -25,6 +25,11 @@ public override DynValue Eval(ScriptExecutionContext context)
 			return expression.Eval(context).ToScalar();
 		}
 
+		public override void ResolveScope(ScriptLoadingContext lcontext)
+		{
+			expression.ResolveScope(lcontext);
+		}
+
 		public override bool EvalLiteral(out DynValue dv)
 		{
 			if (expression.EvalLiteral(out dv))

src/MoonSharp.Interpreter/Tree/Expressions/BinaryOperatorExpression.cs

@@ -360,6 +360,12 @@ public static OpCode OperatorToOpCode(Operator op)
 			}
 		}
 
+		public override void ResolveScope(ScriptLoadingContext lcontext)
+		{
+			m_Exp1.ResolveScope(lcontext);
+			m_Exp2.ResolveScope(lcontext);
+		}
+
 
 		public override void Compile(Execution.VM.ByteCode bc)
 		{

src/MoonSharp.Interpreter/Tree/Expressions/DynamicExprExpression.cs

@@ -15,6 +15,10 @@ public DynamicExprExpression(Expression exp, ScriptLoadingContext lcontext)
 			m_Exp = exp;
 		}
 
+		public override void ResolveScope(ScriptLoadingContext lcontext)
+		{
+			m_Exp.ResolveScope(lcontext);
+		}
 
 		public override DynValue Eval(ScriptExecutionContext context)
 		{

src/MoonSharp.Interpreter/Tree/Expressions/ExprListExpression.cs

@@ -20,6 +20,12 @@ public Expression[] GetExpressions()
 			return expressions.ToArray();
 		}
 
+		public override void ResolveScope(ScriptLoadingContext lcontext)
+		{
+			foreach(var exp in expressions)
+				exp.ResolveScope(lcontext);
+		}
+
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
 			foreach (var exp in expressions)

src/MoonSharp.Interpreter/Tree/Expressions/FunctionCallExpression.cs

@@ -65,6 +65,13 @@ public FunctionCallExpression(ScriptLoadingContext lcontext, Expression function
 			}
 		}
 
+		public override void ResolveScope(ScriptLoadingContext lcontext)
+		{
+			m_Function.ResolveScope(lcontext);
+			foreach(var arg in m_Arguments)
+				arg.ResolveScope(lcontext);
+		}
+
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
 			m_Function.Compile(bc);

src/MoonSharp.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs

@@ -46,22 +46,7 @@ private FunctionDefinitionExpression(ScriptLoadingContext lcontext, bool pushSel
 
 			m_Annotations = lcontext.FunctionAnnotations.ToArray();
 			lcontext.FunctionAnnotations = new List<Annotation>();
-			
-			// create scope
-			// This needs to be up here to allow for arguments to correctly close over ENV
-			// Arguments, however, must come before any other local definitions to avoid closing
-			// over uninitialised variables. (Note for hoisting).
-			lcontext.Scope.PushFunction(this);
-
-			if (m_UsesGlobalEnv)
-			{
-				m_Env = lcontext.Scope.DefineLocal(WellKnownSymbols.ENV);
-			}
-			else
-			{
-				lcontext.Scope.ForceEnvUpValue();
-			}
-			
+	
 			// Parse arguments
 			// here lexer should be at the '(' or at the '|'
 			//Token openRound = CheckTokenType(lcontext, isLambda ? TokenType.Lambda : TokenType.Brk_Open_Round);
@@ -97,24 +82,41 @@ private FunctionDefinitionExpression(ScriptLoadingContext lcontext, bool pushSel
 			// here lexer is at first token of body
 
 			m_Begin = openRound.GetSourceRefUpTo(lcontext.Lexer.Current);
-
-
-			m_ParamNames = DefineArguments(paramnames, lcontext);
 
-			if(m_HasVarArgs) lcontext.Scope.SetHasVarArgs(); //Moved here
-
 			if(isLambda)
 				m_Statement = CreateLambdaBody(lcontext, arrowFunc);
 			else
 				m_Statement = CreateBody(lcontext, openCurly);
 
-			m_StackFrame = lcontext.Scope.PopFunction();
 
 			lcontext.Source.Refs.Add(m_Begin);
 			lcontext.Source.Refs.Add(m_End);
 
 		}
 
+		public override void ResolveScope(ScriptLoadingContext lcontext)
+		{
+			resolved = true;
+			lcontext.Scope.PushFunction(this);
+
+			if (m_UsesGlobalEnv)
+			{
+				m_Env = lcontext.Scope.DefineLocal(WellKnownSymbols.ENV);
+			}
+			else
+			{
+				lcontext.Scope.ForceEnvUpValue();
+			}
+			
+			m_ParamNames = DefineArguments(paramnames, lcontext);
+			
+			if(m_HasVarArgs) lcontext.Scope.SetHasVarArgs(); //Moved here
+			
+			m_Statement.ResolveScope(lcontext);
+			
+			m_StackFrame = lcontext.Scope.PopFunction();
+		}
+
 
 		private Statement CreateLambdaBody(ScriptLoadingContext lcontext, bool arrowFunc)
 		{
@@ -247,7 +249,7 @@ private SymbolRef[] DefineArguments(List<FunctionDefinitionStatement.FunctionPar
 			{
 				if (!names.Add(paramnames[i].Name))
 					paramnames[i].Name = paramnames[i].Name + "@" + i.ToString();
-
+				paramnames[i].DefaultValue?.ResolveScope(lcontext);
 				ret[i] = lcontext.Scope.DefineLocal(paramnames[i].Name);
 			}
 
@@ -281,8 +283,11 @@ public override DynValue Eval(ScriptExecutionContext context)
 			throw new DynamicExpressionException("Dynamic Expressions cannot define new functions.");
 		}
 
+		private bool resolved = false;
+
 		public int CompileBody(ByteCode bc, string friendlyName)
 		{
+			if (!resolved) throw new InternalErrorException("Function definition scope not resolved");
 			//LoadingContext.Scope.PopFunction()
 
 			string funcName = friendlyName ?? ("<" + this.m_Begin.FormatLocation(bc.Script, true) + ">");