Fixes yield proc scheduling. Turns sleeps into an opcode

Content.Tests/DMProject/Tests/Sleeping/YieldOrder.dm

@@ -0,0 +1,58 @@
+var/counter
+#define ExpectOrder(n) ASSERT(++counter == ##n)
+
+/proc/BackgroundSleep(delay, expect)
+	set waitfor = FALSE
+	sleep(delay)
+	world.log << "Expect: [expect]"
+	ExpectOrder(expect)
+
+#define MODE_INLINE 0 // spawn
+#define MODE_BACKGROUND 1 // set waitfor = FALSE + sleep
+#define MODE_RAND 2 // random seeded
+
+#define TestSleep(delay, expect) if(mode == MODE_INLINE || (mode == MODE_RAND && prob(50))){ spawn(##delay) { ExpectOrder(##expect); } } else { BackgroundSleep(##delay, ##expect); }
+
+/proc/TestSequence(mode)
+	counter = 0
+	var/start_tick = world.time
+
+	TestSleep(0, 2)
+	ExpectOrder(1)
+	sleep(0)
+	ExpectOrder(3)
+
+	TestSleep(-1, 4)
+	ExpectOrder(5)
+
+	TestSleep(0, 6)
+	sleep(-1)
+	ExpectOrder(7)
+
+	TestSleep(-1, 8)
+	ExpectOrder(9)
+	sleep(-1)
+	ExpectOrder(10)
+
+	TestSleep(1, 13)
+	sleep(-1)
+	ExpectOrder(11)
+	sleep(0)
+	ExpectOrder(12)
+
+	ASSERT(world.time == start_tick)
+
+	sleep(1)
+	ExpectOrder(14)
+
+/proc/RunTest()
+	world.log << "Inline:"
+	TestSequence(MODE_INLINE)
+
+	world.log << "Background:"
+	TestSequence(MODE_BACKGROUND)
+
+	rand_seed(22475)
+	for(var/i in 1 to 10000)
+		world.log << "Rand-[i]:"
+		TestSequence(MODE_RAND)

Content.Tests/DMTests.cs

@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using OpenDreamRuntime;
 using OpenDreamRuntime.Objects;
+using OpenDreamRuntime.Procs;
 using OpenDreamRuntime.Rendering;
 using OpenDreamShared.Rendering;
 using Robust.Shared.Asynchronous;
@@ -28,6 +29,7 @@ public sealed class DMTests : ContentUnitTest {
 
         [Dependency] private readonly DreamManager _dreamMan = default!;
         [Dependency] private readonly DreamObjectTree _objectTree = default!;
+        [Dependency] private readonly ProcScheduler _procScheduler = default!;
         [Dependency] private readonly ITaskManager _taskManager = default!;
 
         [Flags]
@@ -138,11 +140,11 @@ public void TestFiles(string sourceFile, DMTestFlags testFlags) {
             watch.Start();
 
             // Tick until our inner call has finished
-            while (!callTask.IsCompleted) {
+            while (!callTask.IsCompleted || _procScheduler.HasProcsQueued || _procScheduler.HasProcsSleeping) {
                 _dreamMan.Update();
                 _taskManager.ProcessPendingTasks();
 
-                if (watch.Elapsed.TotalMilliseconds > 500) {
+                if (watch.Elapsed.TotalSeconds > 5) {
                     Assert.Fail("Test timed out");
                 }
             }

DMCompiler/Bytecode/DreamProcOpcode.cs

@@ -139,6 +139,8 @@ public enum DreamProcOpcode : byte {
     Log = 0x81,
     LogE = 0x82,
     Abs = 0x83,
+    [OpcodeMetadata(stackDelta: -1)] Sleep = 0x84,
+    BackgroundSleep = 0x85,
 }
 
 /// <summary>

DMCompiler/Compiler/DM/DMAST.cs

@@ -78,6 +78,10 @@ public void VisitProcStatementSpawn(DMASTProcStatementSpawn statementSpawn) {
             throw new NotImplementedException();
         }
 
+        public void VisitProcStatementSleep(DMASTProcStatementSleep statementSleep) {
+            throw new NotImplementedException();
+        }
+
         public void VisitProcStatementIf(DMASTProcStatementIf statementIf) {
             throw new NotImplementedException();
         }
@@ -920,6 +924,19 @@ public override void Visit(DMASTVisitor visitor) {
         }
     }
 
+    public sealed class DMASTProcStatementSleep : DMASTProcStatement {
+        public DMASTExpression Delay;
+
+        public DMASTProcStatementSleep(Location location, DMASTExpression delay) :
+            base(location) {
+            Delay = delay;
+        }
+
+        public override void Visit(DMASTVisitor visitor) {
+            visitor.VisitProcStatementSleep(this);
+        }
+    }
+
     public sealed class DMASTProcStatementSpawn : DMASTProcStatement {
         public DMASTExpression Delay;
         public readonly DMASTProcBlockInner Body;

DMCompiler/Compiler/DM/DMLexer.cs

@@ -60,6 +60,7 @@ public sealed class DMLexer : TokenLexer {
         { "call", TokenType.DM_Call },
         { "call_ext", TokenType.DM_Call},
         { "spawn", TokenType.DM_Spawn },
+        { "sleep", TokenType.DM_Sleep },
         { "goto", TokenType.DM_Goto },
         { "step", TokenType.DM_Step },
         { "try", TokenType.DM_Try },

DMCompiler/Compiler/DM/DMParser.cs

@@ -100,6 +100,7 @@ public DMParser(DMLexer lexer) : base(lexer) {
             TokenType.DM_Null,
             TokenType.DM_Switch,
             TokenType.DM_Spawn,
+            TokenType.DM_Sleep,
             TokenType.DM_Do,
             TokenType.DM_While,
             TokenType.DM_For,
@@ -715,6 +716,7 @@ public DMASTFile File() {
                 procStatement ??= Switch();
                 procStatement ??= Continue();
                 procStatement ??= Break();
+                procStatement ??= Sleep();
                 procStatement ??= Spawn();
                 procStatement ??= While();
                 procStatement ??= DoWhile();
@@ -1059,6 +1061,23 @@ private DMASTProcStatementSet[] ProcSetEnd(bool allowMultiple) {
             }
         }
 
+        public DMASTProcStatementSleep? Sleep() {
+            var loc = Current().Location;
+
+            if (Check(TokenType.DM_Sleep)) {
+                Whitespace();
+                bool hasParenthesis = Check(TokenType.DM_LeftParenthesis);
+                Whitespace();
+                DMASTExpression? delay = Expression();
+                if (delay == null) Error("Expected delay to sleep for");
+                if (hasParenthesis) ConsumeRightParenthesis();
+
+                return new DMASTProcStatementSleep(loc, delay ?? new DMASTConstantInteger(loc, 0));
+            } else {
+                return null;
+            }
+        }
+
         public DMASTProcStatementIf? If() {
             var loc = Current().Location;
 

DMCompiler/DM/DMProc.cs

@@ -459,20 +459,19 @@ public void MarkLoopContinue(string loopLabel) {
             AddLabel($"{loopLabel}_continue");
         }
 
-        public void BackgroundSleep() {
-            // TODO This seems like a bad way to handle background, doesn't it?
-
-            if ((Attributes & ProcAttributes.Background) == ProcAttributes.Background) {
-                if (!DMObjectTree.TryGetGlobalProc("sleep", out var sleepProc)) {
-                    throw new CompileErrorException(Location, "Cannot do a background sleep without a sleep proc");
-                }
-
-                PushFloat(-1); // argument given to sleep()
-                Call(DMReference.CreateGlobalProc(sleepProc.Id), DMCallArgumentsType.FromStack, 1);
-                Pop(); // Pop the result of the sleep call
+        public void SleepDelayPushed() => WriteOpcode(DreamProcOpcode.Sleep);
+
+        public void Sleep(float delay) {
+            if(delay == -1.0f) // yielding
+                WriteOpcode(DreamProcOpcode.BackgroundSleep);
+            else {
+                PushFloat(delay);
+                WriteOpcode(DreamProcOpcode.Sleep);
             }
         }
 
+        public void BackgroundSleep() => WriteOpcode(DreamProcOpcode.BackgroundSleep);
+
         public void LoopJumpToStart(string loopLabel) {
             BackgroundSleep();
             Jump($"{loopLabel}_start");

DMCompiler/DM/Visitors/DMASTSimplifier.cs

@@ -124,6 +124,10 @@ public void VisitProcStatementSpawn(DMASTProcStatementSpawn statementSpawn) {
             statementSpawn.Body.Visit(this);
         }
 
+        public void VisitProcStatementSleep(DMASTProcStatementSleep statementSleep) {
+            SimplifyExpression(ref statementSleep.Delay);
+        }
+
         public void VisitProcStatementGoto(DMASTProcStatementGoto statementGoto) {
 
         }

DMCompiler/DM/Visitors/DMProcBuilder.cs

@@ -121,6 +121,7 @@ public void ProcessStatement(DMASTProcStatement statement) {
                 case DMASTProcStatementBreak statementBreak: ProcessStatementBreak(statementBreak); break;
                 case DMASTProcStatementDel statementDel: ProcessStatementDel(statementDel); break;
                 case DMASTProcStatementSpawn statementSpawn: ProcessStatementSpawn(statementSpawn); break;
+                case DMASTProcStatementSleep statementSleep: ProcessStatementSleep(statementSleep); break;
                 case DMASTProcStatementReturn statementReturn: ProcessStatementReturn(statementReturn); break;
                 case DMASTProcStatementIf statementIf: ProcessStatementIf(statementIf); break;
                 case DMASTProcStatementFor statementFor: ProcessStatementFor(statementFor); break;
@@ -317,6 +318,21 @@ public void ProcessStatementSpawn(DMASTProcStatementSpawn statementSpawn) {
             _proc.AddLabel(afterSpawnLabel);
         }
 
+        public void ProcessStatementSleep(DMASTProcStatementSleep statementSleep) {
+            var expr = DMExpression.Create(_dmObject, _proc, statementSleep.Delay);
+            if (expr.TryAsConstant(out var constant)) {
+                if (constant is Number constantNumber) {
+                    _proc.Sleep(constantNumber.Value);
+                    return;
+                }
+
+                constant.EmitPushValue(_dmObject, _proc);
+            } else
+                expr.EmitPushValue(_dmObject, _proc);
+
+            _proc.SleepDelayPushed();
+        }
+
         public void ProcessStatementVarDeclaration(DMASTProcStatementVarDeclaration varDeclaration) {
             if (varDeclaration.IsGlobal) { return; } //Currently handled by DMObjectBuilder
 

DMCompiler/DMStandard/_Standard.dm

@@ -80,7 +80,6 @@ proc/roll(ndice = 1, sides)
 proc/round(A, B)
 proc/sha1(input)
 proc/shutdown(Addr,Natural = 0)
-proc/sleep(Delay)
 proc/sorttext(T1, T2)
 proc/sorttextEx(T1, T2)
 proc/sound(file, repeat = 0, wait, channel, volume)

OpenDreamRuntime/Procs/AsyncNativeProc.cs

@@ -9,7 +9,7 @@
 
 namespace OpenDreamRuntime.Procs {
     public sealed class AsyncNativeProc : DreamProc {
-        public sealed class State : ProcState {
+        public sealed class State : AsyncProcState {
             public static readonly Stack<State> Pool = new();
 
             // IoC dependencies instead of proc fields because _proc can be null
@@ -52,7 +52,7 @@ public void Initialize(AsyncNativeProc? proc, Func<State, Task<DreamValue>> task
             }
 
             // Used to avoid reentrant resumptions in our proc
-            public void SafeResume() {
+            public override void SafeResume() {
                 if (_inResume) {
                     return;
                 }

OpenDreamRuntime/Procs/AsyncProcState.cs

@@ -0,0 +1,5 @@
+namespace OpenDreamRuntime.Procs {
+    public abstract class AsyncProcState : ProcState {
+        public abstract void SafeResume();
+    }
+}