Spike the use-async-scheduler optional feature from RFC 957

package.json

@@ -280,6 +280,7 @@
       "@ember/routing/route.js": "ember-source/@ember/routing/route.js",
       "@ember/routing/router-service.js": "ember-source/@ember/routing/router-service.js",
       "@ember/routing/router.js": "ember-source/@ember/routing/router.js",
+      "@ember/runloop/-private/scheduler-loop.js": "ember-source/@ember/runloop/-private/scheduler-loop.js",
       "@ember/runloop/index.js": "ember-source/@ember/runloop/index.js",
       "@ember/scheduler/index.js": "ember-source/@ember/scheduler/index.js",
       "@ember/scheduler/strategy.js": "ember-source/@ember/scheduler/strategy.js",

packages/@ember/-internals/environment/lib/env.ts

@@ -143,6 +143,22 @@ export const ENV = {
   */
   _DEFAULT_ASYNC_OBSERVERS: false,
 
+  /**
+    Whether Ember schedules its own work (rendering, runloop-scheduled
+    callbacks, promise resolution) through `@ember/scheduler` instead of
+    backburner and RSVP, per RFC 0957.
+
+    This is not intended to be set directly, as the implementation may change in
+    the future. Use `@ember/optional-features` instead.
+
+    @property _USE_ASYNC_SCHEDULER
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _USE_ASYNC_SCHEDULER: false,
+
   /**
     Controls the maximum number of scheduled rerenders without "settling". In general,
     applications should not need to modify this environment variable, but please

packages/@ember/-internals/glimmer/lib/async-revalidate.ts

@@ -0,0 +1,22 @@
+import { scheduleOnce } from '@ember/runloop';
+
+// Indirection between environment.ts (which needs to schedule revalidation
+// from the glimmer global context) and base-renderer.ts (which owns the
+// renderers and implements the flush), so neither has to import the other.
+
+let flushFn: () => void = () => {};
+
+export function _setAsyncRenderFlush(fn: () => void): void {
+  flushFn = fn;
+}
+
+function runAsyncRenderFlush(): void {
+  flushFn();
+}
+
+// Schedules the async rendering pass (deduplicated) into the scheduler's
+// render phase. Only used when the `use-async-scheduler` optional feature
+// is enabled.
+export function _scheduleAsyncRevalidate(): void {
+  scheduleOnce('render', null, runAsyncRenderFlush);
+}

packages/@ember/-internals/glimmer/lib/base-renderer.ts

@@ -1,7 +1,9 @@
 import { ENV } from '@ember/-internals/environment/lib/env';
 import type { InternalOwner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
-import { _backburner, _getCurrentRunLoop } from '@ember/runloop';
+import { _backburner, _getCurrentRunLoop, schedule } from '@ember/runloop';
+import { flushAsyncObservers } from '@ember/-internals/metal/lib/observer';
+import { _scheduleAsyncRevalidate, _setAsyncRenderFlush } from './async-revalidate';
 import {
   associateDestroyableChild,
   destroy,
@@ -177,10 +179,14 @@ export function renderSettled() {
     let resolve!: () => void;
     let promise = new Promise<void>((r) => (resolve = r));
     renderSettledDeferred = { promise, resolve };
-    // if there is no current runloop, the promise created above will not have
-    // a chance to resolve (because its resolved in backburner's "end" event)
-    if (!_getCurrentRunLoop()) {
-      // ensure a runloop has been kicked off
+    if (ENV._USE_ASYNC_SCHEDULER) {
+      // ensure a revalidation pass is scheduled; it resolves the promise
+      // once every renderer is valid
+      _scheduleAsyncRevalidate();
+    } else if (!_getCurrentRunLoop()) {
+      // if there is no current runloop, the promise created above will not
+      // have a chance to resolve (because its resolved in backburner's "end"
+      // event); ensure a runloop has been kicked off
       _backburner.schedule('actions', null, NO_OP);
     }
   }
@@ -193,7 +199,11 @@ function resolveRenderPromise() {
     let resolve = renderSettledDeferred.resolve;
     renderSettledDeferred = null;
 
-    _backburner.join(null, resolve);
+    if (ENV._USE_ASYNC_SCHEDULER) {
+      resolve();
+    } else {
+      _backburner.join(null, resolve);
+    }
   }
 }
 
@@ -218,6 +228,38 @@ function loopEnd() {
 _backburner.on('begin', loopBegin);
 _backburner.on('end', loopEnd);
 
+// The async rendering pass used when the `use-async-scheduler` optional
+// feature is enabled: revalidation is scheduled into the scheduler's render
+// phase instead of backburner's `render` queue, so rendering happens before
+// the next paint rather than at the end of the current runloop.
+function flushAsyncRendering(): void {
+  flushAsyncObservers(schedule);
+
+  for (let renderer of renderers) {
+    renderer.state.revalidate(renderer);
+  }
+
+  for (let renderer of renderers) {
+    if (!renderer.isValid()) {
+      if (loops > ENV._RERENDER_LOOP_LIMIT) {
+        loops = 0;
+        // TODO: do something better
+        renderer.destroy();
+        throw new Error('infinite rendering invalidation detected');
+      }
+      loops++;
+      // the render phase resolves in-window when awaited during its own
+      // flush, so this reflush happens within the same frame
+      _scheduleAsyncRevalidate();
+      return;
+    }
+  }
+  loops = 0;
+  resolveRenderPromise();
+}
+
+_setAsyncRenderFlush(flushAsyncRendering);
+
 type Resolver = ClassicResolver;
 
 interface RendererData {
@@ -369,6 +411,10 @@ export class RendererState {
   }
 
   scheduleRevalidate(renderer: BaseRenderer): void {
+    if (ENV._USE_ASYNC_SCHEDULER) {
+      _scheduleAsyncRevalidate();
+      return;
+    }
     _backburner.scheduleOnce('render', this, this.revalidate, renderer);
   }
 

packages/@ember/-internals/glimmer/lib/environment.ts

@@ -9,6 +9,7 @@ import type { DeprecationOptions } from '@ember/debug/lib/deprecate';
 import { schedule, _backburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import setGlobalContext from '@glimmer/global-context';
+import { _scheduleAsyncRevalidate } from './async-revalidate';
 import type { EnvironmentDelegate } from '@glimmer/runtime/lib/environment';
 import { debug } from '@glimmer/validator/lib/debug';
 import toIterator from './utils/iterator';
@@ -21,6 +22,10 @@ import toBool from './utils/to-bool';
 
 setGlobalContext({
   scheduleRevalidate() {
+    if (ENV._USE_ASYNC_SCHEDULER) {
+      _scheduleAsyncRevalidate();
+      return;
+    }
     _backburner.ensureInstance();
   },
 

packages/@ember/-internals/runtime/lib/ext/rsvp.ts

@@ -1,13 +1,24 @@
 import * as RSVP from 'rsvp';
+import { ENV } from '@ember/-internals/environment/lib/env';
 import { _backburner, _rsvpErrorQueue } from '@ember/runloop';
 import { getDispatchOverride } from '@ember/-internals/error-handling';
 import { assert } from '@ember/debug';
 
-RSVP.configure('async', (callback: unknown, promise: unknown) => {
+RSVP.configure('async', (callback: Function, promise: unknown) => {
+  if (ENV._USE_ASYNC_SCHEDULER) {
+    // RFC 0957: Ember no longer routes RSVP's flush through the runloop;
+    // resolution happens on the microtask queue like a native promise.
+    void Promise.resolve().then(() => callback(promise));
+    return;
+  }
   _backburner.schedule('actions', null, callback, promise);
 });
 
-RSVP.configure('after', (cb: unknown) => {
+RSVP.configure('after', (cb: () => void) => {
+  if (ENV._USE_ASYNC_SCHEDULER) {
+    setTimeout(cb, 0);
+    return;
+  }
   _backburner.schedule(_rsvpErrorQueue, null, cb);
 });