src/Pure/Build/build_process.scala

     pending: State.Pending = Map.empty,
     running: State.Running = Map.empty,
     results: State.Results = Map.empty
   ) {
     require(serial >= 0, "serial underflow")
-    def inc_serial: State = {
+
+    def next_serial: Long = {
       require(serial < Long.MaxValue, "serial overflow")
-      copy(serial = serial + 1)
-    }
+      serial + 1
+    }
+    def inc_serial: State = copy(serial = next_serial)
 
     def ready: List[Task] = pending.valuesIterator.filter(_.is_ready).toList.sortBy(_.name)
     def next_ready: List[Task] = ready.filter(entry => !is_running(entry.name))
 
     def remove_pending(a: String): State =

       db: SQL.Database,
       worker_uuid: String,
       state: State,
       old_state: State
     ): State = {
+      val serial = state.next_serial
       val changed =
         List(
           update_sessions(db, state.sessions, old_state.sessions),
           update_pending(db, state.pending, old_state.pending),
           update_running(db, state.running, old_state.running),
-          update_results(db, state.results, old_state.results))
-
-      val state1 = if (changed.exists(identity)) state.inc_serial else state
-      if (state1.serial != state.serial) stamp_worker(db, worker_uuid, state1.serial)
-
-      state1
+          update_results(db, state.results, old_state.results)
+        ).exists(identity)
+
+      if (changed) {
+        stamp_worker(db, worker_uuid, serial)
+        state.copy(serial = serial)
+      }
+      else state
     }
   }
 
   def read_builds(db: SQL.Database): List[Build] =
     private_data.transaction_lock(db, create = true, label = "Build_Process.read_builds") {