Lua-CSharp can't handle break statement properly

[yuychu]

In the following code, the expected output when running in standard Lua should be 50. However, when executed in the Lua-CSharp implementation, the actual output is 100.

local n = 0
while n < 100 do
    n = n + 1
    if n == 50 then break end
    while false do
        n = n + 7
        break
    end
end
print(n)

Expected Behavior
Output:
50
Actual Behavior (Lua-CSharp)
Output:
100

After reviewing the code, I believe there is an issue with how the compiler handles break statements. The break queue is maintained in the FunctionCompilationContext, and all scopes share a single queue. This causes a problem when compiling a nested while statement: while compiling the inner while, the break queue is processed in such a way that breaks belonging to the outer while loop are also resolved, leading to incorrect jump targets.

In fact, during additional testing with other examples, I found that this behavior can sometimes result in unintended infinite loops.

[yuychu]

The relevant compiler implementation is as follows:

Lua-CSharp/src/Lua/CodeAnalysis/Compilation/FunctionCompilationContext.cs

Lines 389 to 413 in ad6a5a1

	public void AddUnresolvedBreak(BreakDescription description, SourcePosition sourcePosition)
	{
	if (LoopLevel == 0)
	{
	LuaParseException.BreakNotInsideALoop(ChunkName, sourcePosition);
	}
	breakQueue.Add(description);
	}
	public void ResolveAllBreaks(byte startPosition, int endPosition, ScopeCompilationContext loopScope)
	{
	foreach (var description in breakQueue.AsSpan())
	{
	ref var instruction = ref Instructions[description.Index];
	if (loopScope.HasCapturedLocalVariables)
	{
	instruction.A = startPosition;
	}
	instruction.SBx = endPosition - description.Index;
	}
	breakQueue.Clear();
	}

Lua-CSharp/src/Lua/CodeAnalysis/Compilation/LuaCompiler.cs

Lines 750 to 759 in ad6a5a1

	public bool VisitBreakStatementNode(BreakStatementNode node, ScopeCompilationContext context)
	{
	context.Function.AddUnresolvedBreak(new()
	{
	Index = context.Function.Instructions.Length
	}, node.Position);
	context.PushInstruction(Instruction.Jmp(0, 0), node.Position);
	return true;
	}

Lua-CSharp/src/Lua/CodeAnalysis/Compilation/LuaCompiler.cs

Lines 870 to 899 in ad6a5a1

	public bool VisitWhileStatementNode(WhileStatementNode node, ScopeCompilationContext context)
	{
	var conditionIndex = context.Function.Instructions.Length;
	context.PushInstruction(Instruction.Jmp(0, 0), node.Position);
	context.Function.LoopLevel++;
	using var scopeContext = context.CreateChildScope();
	var stackPosition = scopeContext.StackPosition;
	foreach (var childNode in node.Nodes)
	{
	childNode.Accept(this, scopeContext);
	}
	context.Function.LoopLevel--;
	// set JMP sBx
	scopeContext.Function.Instructions[conditionIndex].SBx = scopeContext.Function.Instructions.Length - 1 - conditionIndex;
	CompileConditionNode(node.ConditionNode, scopeContext, false);
	var a = scopeContext.HasCapturedLocalVariables ? (byte)(1 + stackPosition) : (byte)0;
	scopeContext.PushInstruction(Instruction.Jmp(a, conditionIndex - context.Function.Instructions.Length), node.Position);
	scopeContext.TryPushCloseUpValue(scopeContext.StackPosition, node.Position);
	// resolve break statements inside while block
	context.Function.ResolveAllBreaks(scopeContext.StackPosition, context.Function.Instructions.Length - 1, scopeContext);
	return true;
	}

[yuychu]

I was hoping to get some feedback on this issue, since it seems quite important.
The incorrect handling of break affects the control-flow semantics and leads to results that differ from standard Lua, even causing unexpected infinite loops in some cases.
It might not be a simple edge case, but rather something fundamental in how scopes and break queues are managed.
I’d really appreciate it if someone could take a look or confirm whether this behavior is intended.