ember-source 6.4.0-alpha.2 → 6.4.0-alpha.3

package/dist/packages/@glimmer/owner/index.js

@@ -1,3 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
 const OWNER = Symbol("OWNER");
 
 /**

package/dist/packages/@glimmer/program/index.js

@@ -1,13 +1,18 @@
 import { getInternalHelperManager, getInternalModifierManager, getInternalComponentManager, capabilityFlagsFrom, getComponentTemplate, managerHasCapability } from '../manager/index.js';
 import { templateFactory } from '../opcode-compiler/index.js';
-import { constants, enumerate, assert as debugAssert, unwrapTemplate, expect, unwrap } from '../util/index.js';
+import { enumerate } from '../util/index.js';
 import { InternalComponentCapabilities, OPERAND_LEN_MASK, ARG_SHIFT, MACHINE_MASK, TYPE_MASK } from '../vm/index.js';
 import { SexpOpcodes as opcodes } from '../wire-format/index.js';
 
+function unwrapTemplate(template) {
+  if ("error" === template.result) throw new Error(`Compile Error: ${template.problem} @ ${template.span.start}..${template.span.end}`);
+  return template;
+}
+
 /**
  * Default component template, which is a plain yield
  */
-const DEFAULT_TEMPLATE_BLOCK = [[[opcodes.Yield, 1, null]], ["&default"], !1, []],
+const DEFAULT_TEMPLATE_BLOCK = [[[opcodes.Yield, 1, null]], ["&default"], []],
   DEFAULT_TEMPLATE = {
     // random uuid
     id: "1b32f5c2-7623-43d6-a0ad-9672898920a1",
@@ -17,12 +22,9 @@ const DEFAULT_TEMPLATE_BLOCK = [[[opcodes.Yield, 1, null]], ["&default"], !1, []
     isStrictMode: !0
   },
   WELL_KNOWN_EMPTY_ARRAY = Object.freeze([]),
-  STARTER_CONSTANTS = constants(WELL_KNOWN_EMPTY_ARRAY),
+  STARTER_CONSTANTS = [!1, !0, null, void 0, WELL_KNOWN_EMPTY_ARRAY],
   WELL_KNOWN_EMPTY_ARRAY_POSITION = STARTER_CONSTANTS.indexOf(WELL_KNOWN_EMPTY_ARRAY);
-class CompileTimeConstantImpl {
-  // `0` means NULL
-  values = STARTER_CONSTANTS.slice();
-  indexMap = new Map(this.values.map((value, index) => [value, index]));
+class ConstantsImpl {
   value(value) {
     let indexMap = this.indexMap,
       index = indexMap.get(value);
@@ -37,35 +39,9 @@ class CompileTimeConstantImpl {
   toPool() {
     return this.values;
   }
-}
-class RuntimeConstantsImpl {
-  values;
-  constructor(pool) {
-    this.values = pool;
-  }
-  getValue(handle) {
-    return this.values[handle];
-  }
-  getArray(value) {
-    let handles = this.getValue(value),
-      reified = new Array(handles.length);
-    for (const [i, n] of enumerate(handles)) reified[i] = this.getValue(n);
-    return reified;
+  hasHandle(handle) {
+    return this.values.length > handle;
   }
-}
-class ConstantsImpl extends CompileTimeConstantImpl {
-  reifiedArrs = {
-    [WELL_KNOWN_EMPTY_ARRAY_POSITION]: WELL_KNOWN_EMPTY_ARRAY
-  };
-  defaultTemplate = templateFactory(DEFAULT_TEMPLATE)();
-  // Used for tests and debugging purposes, and to be able to analyze large apps
-  // This is why it's enabled even in production
-  helperDefinitionCount = 0;
-  modifierDefinitionCount = 0;
-  componentDefinitionCount = 0;
-  helperDefinitionCache = new WeakMap();
-  modifierDefinitionCache = new WeakMap();
-  componentDefinitionCache = new WeakMap();
   helper(definitionState,
   // TODO: Add a way to expose resolved name for debugging
   _resolvedName = null, isOptional) {
@@ -73,7 +49,6 @@ class ConstantsImpl extends CompileTimeConstantImpl {
     if (void 0 === handle) {
       let managerOrHelper = getInternalHelperManager(definitionState, isOptional);
       if (null === managerOrHelper) return this.helperDefinitionCache.set(definitionState, null), null;
-      debugAssert(managerOrHelper, "BUG: expected manager or helper");
       let helper = "function" == typeof managerOrHelper ? managerOrHelper : managerOrHelper.getHelper(definitionState);
       handle = this.value(helper), this.helperDefinitionCache.set(definitionState, handle), this.helperDefinitionCount++;
     }
@@ -93,12 +68,11 @@ class ConstantsImpl extends CompileTimeConstantImpl {
     }
     return handle;
   }
-  component(definitionState, owner, isOptional) {
+  component(definitionState, owner, isOptional, debugName) {
     let definition = this.componentDefinitionCache.get(definitionState);
     if (void 0 === definition) {
       let manager = getInternalComponentManager(definitionState, isOptional);
       if (null === manager) return this.componentDefinitionCache.set(definitionState, null), null;
-      debugAssert(manager, "BUG: expected manager");
       let template,
         capabilities = capabilityFlagsFrom(manager.getCapabilities(definitionState)),
         templateFactory = getComponentTemplate(definitionState),
@@ -106,12 +80,11 @@ class ConstantsImpl extends CompileTimeConstantImpl {
       template = managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout) ? templateFactory?.(owner) : templateFactory?.(owner) ?? this.defaultTemplate, void 0 !== template && (template = unwrapTemplate(template), compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout()), definition = {
         resolvedName: null,
         handle: -1,
-        // replaced momentarily
         manager: manager,
         capabilities: capabilities,
         state: definitionState,
         compilable: compilable
-      }, definition.handle = this.value(definition), this.componentDefinitionCache.set(definitionState, definition), this.componentDefinitionCount++;
+      }, definition.handle = this.value(definition), debugName && (definition.debugName = debugName), this.componentDefinitionCache.set(definitionState, definition), this.componentDefinitionCount++;
     }
     return definition;
   }
@@ -128,17 +101,16 @@ class ConstantsImpl extends CompileTimeConstantImpl {
       managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout) || (template = template ?? this.defaultTemplate), null !== template && (template = unwrapTemplate(template), compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout()), definition = {
         resolvedName: resolvedName,
         handle: -1,
-        // replaced momentarily
         manager: manager,
         capabilities: capabilities,
         state: state,
         compilable: compilable
       }, definition.handle = this.value(definition), this.componentDefinitionCache.set(resolvedDefinition, definition), this.componentDefinitionCount++;
     }
-    return expect(definition, "BUG: resolved component definitions cannot be null");
+    return definition;
   }
   getValue(index) {
-    return debugAssert(index >= 0, `cannot get value for handle: ${index}`), this.values[index];
+    return this.values[index];
   }
   getArray(index) {
     let reifiedArrs = this.reifiedArrs,
@@ -151,11 +123,18 @@ class ConstantsImpl extends CompileTimeConstantImpl {
     }
     return reified;
   }
+  constructor() {
+    this.reifiedArrs = {
+      [WELL_KNOWN_EMPTY_ARRAY_POSITION]: WELL_KNOWN_EMPTY_ARRAY
+    }, this.defaultTemplate = templateFactory(DEFAULT_TEMPLATE)(),
+    // Used for tests and debugging purposes, and to be able to analyze large apps
+    // This is why it's enabled even in production
+    this.helperDefinitionCount = 0, this.modifierDefinitionCount = 0, this.componentDefinitionCount = 0, this.values = STARTER_CONSTANTS.slice(), this.indexMap = new Map(this.values.map((value, index) => [value, index])), this.helperDefinitionCache = new WeakMap(), this.modifierDefinitionCache = new WeakMap(), this.componentDefinitionCache = new WeakMap();
+  }
 }
 class RuntimeOpImpl {
-  offset = 0;
   constructor(heap) {
-    this.heap = heap;
+    this.heap = heap, this.offset = 0;
   }
   get size() {
     return 1 + ((this.heap.getbyaddr(this.offset) & OPERAND_LEN_MASK) >> ARG_SHIFT);
@@ -176,38 +155,9 @@ class RuntimeOpImpl {
     return this.heap.getbyaddr(this.offset + 3);
   }
 }
-var TableSlotState = function (TableSlotState) {
-  return TableSlotState[TableSlotState.Allocated = 0] = "Allocated", TableSlotState[TableSlotState.Freed = 1] = "Freed", TableSlotState[TableSlotState.Purged = 2] = "Purged", TableSlotState[TableSlotState.Pointer = 3] = "Pointer", TableSlotState;
-}(TableSlotState || {});
-class RuntimeHeapImpl {
-  heap;
-  table;
-  constructor(serializedHeap) {
-    let {
-      buffer: buffer,
-      table: table
-    } = serializedHeap;
-    this.heap = new Int32Array(buffer), this.table = table;
-  }
-  // It is illegal to close over this address, as compaction
-  // may move it. However, it is legal to use this address
-  // multiple times between compactions.
-  getaddr(handle) {
-    return unwrap(this.table[handle]);
-  }
-  getbyaddr(address) {
-    return expect(this.heap[address], "Access memory out of bounds of the heap");
-  }
-  sizeof(handle) {
-    return this.table, -1;
-  }
-}
-function hydrateHeap(serializedHeap) {
-  return new RuntimeHeapImpl(serializedHeap);
-}
 
 /**
- * The Heap is responsible for dynamically allocating
+ * The Program Heap is responsible for dynamically allocating
  * memory in which we read/write the VM's instructions
  * from/to. When we malloc we pass out a VMHandle, which
  * is used as an indirect way of accessing the memory during
@@ -226,14 +176,12 @@ function hydrateHeap(serializedHeap) {
  * valid during the execution. This means you cannot close
  * over them as you will have a bad memory access exception.
  */
-class HeapImpl {
-  offset = 0;
-  heap;
-  handleTable;
-  handleState;
-  handle = 0;
+class ProgramHeapImpl {
   constructor() {
-    this.heap = new Int32Array(1048576), this.handleTable = [], this.handleState = [];
+    this.offset = 0, this.handle = 0, this.heap = new Int32Array(1048576), this.handleTable = [], this.handleState = [];
+  }
+  entries() {
+    return this.offset;
   }
   pushRaw(value) {
     this.sizeCheck(), this.heap[this.offset++] = value;
@@ -254,7 +202,7 @@ class HeapImpl {
     }
   }
   getbyaddr(address) {
-    return unwrap(this.heap[address]);
+    return this.heap[address];
   }
   setbyaddr(address, value) {
     this.heap[address] = value;
@@ -271,13 +219,13 @@ class HeapImpl {
   // may move it. However, it is legal to use this address
   // multiple times between compactions.
   getaddr(handle) {
-    return unwrap(this.handleTable[handle]);
+    return this.handleTable[handle];
   }
   sizeof(handle) {
     return this.handleTable, -1;
   }
   free(handle) {
-    this.handleState[handle] = TableSlotState.Freed;
+    this.handleState[handle] = 1;
   }
   /**
   * The heap uses the [Mark-Compact Algorithm](https://en.wikipedia.org/wiki/Mark-compact_algorithm) to shift
@@ -294,37 +242,22 @@ class HeapImpl {
         heap: heap
       } = this;
     for (let i = 0; i < length; i++) {
-      let offset = unwrap(handleTable[i]),
-        size = unwrap(handleTable[i + 1]) - unwrap(offset),
+      let offset = handleTable[i],
+        size = handleTable[i + 1] - offset,
         state = handleState[i];
-      if (state !== TableSlotState.Purged) if (state === TableSlotState.Freed)
+      if (2 !== state) if (1 === state)
         // transition to "already freed" aka "purged"
         // a good improvement would be to reuse
         // these slots
-        handleState[i] = TableSlotState.Purged, compactedSize += size;else if (state === TableSlotState.Allocated) {
-        for (let j = offset; j <= i + size; j++) heap[j - compactedSize] = unwrap(heap[j]);
+        handleState[i] = 2, compactedSize += size;else if (0 === state) {
+        for (let j = offset; j <= i + size; j++) heap[j - compactedSize] = heap[j];
         handleTable[i] = offset - compactedSize;
-      } else state === TableSlotState.Pointer && (handleTable[i] = offset - compactedSize);
+      } else 3 === state && (handleTable[i] = offset - compactedSize);
     }
     this.offset = this.offset - compactedSize;
   }
-  capture(offset = this.offset) {
-    // Only called in eager mode
-    let buffer = function (arr, start, end) {
-      if (void 0 !== arr.slice) return arr.slice(start, end);
-      let ret = new Int32Array(end);
-      for (; start < end; start++) ret[start] = unwrap(arr[start]);
-      return ret;
-    }(this.heap, 0, offset).buffer;
-    return {
-      handle: this.handle,
-      table: this.handleTable,
-      buffer: buffer
-    };
-  }
 }
-class RuntimeProgramImpl {
-  _opcode;
+class ProgramImpl {
   constructor(constants, heap) {
     this.constants = constants, this.heap = heap, this._opcode = new RuntimeOpImpl(this.heap);
   }
@@ -335,8 +268,8 @@ class RuntimeProgramImpl {
 function artifacts() {
   return {
     constants: new ConstantsImpl(),
-    heap: new HeapImpl()
+    heap: new ProgramHeapImpl()
   };
 }
 
-export { CompileTimeConstantImpl, ConstantsImpl, HeapImpl, RuntimeConstantsImpl, RuntimeHeapImpl, RuntimeOpImpl, RuntimeProgramImpl, artifacts, hydrateHeap };
+export { ConstantsImpl, ProgramHeapImpl, ProgramImpl, RuntimeOpImpl, artifacts };

package/dist/packages/@glimmer/reference/index.js

@@ -1,28 +1,16 @@
 import { setProp, getProp, toIterator, getPath } from '../global-context/index.js';
-import { expect, isDict, EMPTY_ARRAY, isObject } from '../util/index.js';
-import { CONSTANT_TAG, validateTag, track, valueForTag, consumeTag, dirtyTag as DIRTY_TAG, createTag, INITIAL } from '../validator/index.js';
+import { isDict, EMPTY_ARRAY, isIndexable } from '../util/index.js';
+import { CONSTANT_TAG, validateTag, track, valueForTag, consumeTag, createTag, dirtyTag as DIRTY_TAG, INITIAL } from '../validator/index.js';
 import { isDevelopingApp } from '@embroider/macros';
 
-const REFERENCE = Symbol("REFERENCE"),
-  COMPUTE = 1,
-  UNBOUND = 2;
-
-//////////
+const REFERENCE = Symbol("REFERENCE");
 class ReferenceImpl {
-  [REFERENCE];
-  tag = null;
-  lastRevision = INITIAL;
-  lastValue;
-  children = null;
-  compute = null;
-  update = null;
-  debugLabel;
   constructor(type) {
-    this[REFERENCE] = type;
+    this.tag = null, this.lastRevision = INITIAL, this.children = null, this.compute = null, this.update = null, this[REFERENCE] = type;
   }
 }
 function createPrimitiveRef(value) {
-  const ref = new ReferenceImpl(UNBOUND);
+  const ref = new ReferenceImpl(2);
   return ref.tag = CONSTANT_TAG, ref.lastValue = value, isDevelopingApp() && (ref.debugLabel = String(value)), ref;
 }
 const UNDEFINED_REFERENCE = createPrimitiveRef(void 0),
@@ -34,11 +22,11 @@ function createConstRef(value, debugLabel) {
   return ref.lastValue = value, ref.tag = CONSTANT_TAG, isDevelopingApp() && (ref.debugLabel = debugLabel), ref;
 }
 function createUnboundRef(value, debugLabel) {
-  const ref = new ReferenceImpl(UNBOUND);
+  const ref = new ReferenceImpl(2);
   return ref.lastValue = value, ref.tag = CONSTANT_TAG, isDevelopingApp() && (ref.debugLabel = debugLabel), ref;
 }
 function createComputeRef(compute, update = null, debugLabel = "unknown") {
-  const ref = new ReferenceImpl(COMPUTE);
+  const ref = new ReferenceImpl(1);
   return ref.compute = compute, ref.update = update, isDevelopingApp() && (ref.debugLabel = `(result of a \`${debugLabel}\` helper)`), ref;
 }
 function createReadOnlyRef(ref) {
@@ -72,6 +60,7 @@ function valueForRef(_ref) {
         compute: compute
       } = ref,
       newTag = track(() => {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
         lastValue = ref.lastValue = compute();
       }, isDevelopingApp() && ref.debugLabel);
     tag = ref.tag = newTag, ref.lastRevision = valueForTag(newTag);
@@ -79,15 +68,18 @@ function valueForRef(_ref) {
   return consumeTag(tag), lastValue;
 }
 function updateRef(_ref, value) {
-  expect(_ref.update, "called update on a non-updatable reference")(value);
+  (0, _ref.update)(value);
 }
 function childRefFor(_parentRef, path) {
   const parentRef = _parentRef,
     type = parentRef[REFERENCE];
   let child,
     children = parentRef.children;
-  if (null === children) children = parentRef.children = new Map();else if (child = children.get(path), void 0 !== child) return child;
-  if (type === UNBOUND) {
+  if (null === children) children = parentRef.children = new Map();else {
+    const next = children.get(path);
+    if (next) return next;
+  }
+  if (2 === type) {
     const parent = valueForRef(parentRef);
     child = isDict(parent) ? createUnboundRef(parent[path], isDevelopingApp() && `${parentRef.debugLabel}.${path}`) : UNDEFINED_REFERENCE;
   } else child = createComputeRef(() => {
@@ -114,8 +106,6 @@ const NULL_IDENTITY = {},
   INDEX = (_, index) => String(index),
   IDENTITY = item => null === item ? NULL_IDENTITY : item;
 class WeakMapWithPrimitives {
-  _weakMap;
-  _primitiveMap;
   get weakMap() {
     return void 0 === this._weakMap && (this._weakMap = new WeakMap()), this._weakMap;
   }
@@ -123,10 +113,10 @@ class WeakMapWithPrimitives {
     return void 0 === this._primitiveMap && (this._primitiveMap = new Map()), this._primitiveMap;
   }
   set(key, value) {
-    isObject(key) ? this.weakMap.set(key, value) : this.primitiveMap.set(key, value);
+    isIndexable(key) ? this.weakMap.set(key, value) : this.primitiveMap.set(key, value);
   }
   get(key) {
-    return isObject(key) ? this.weakMap.get(key) : this.primitiveMap.get(key);
+    return isIndexable(key) ? this.weakMap.get(key) : this.primitiveMap.get(key);
   }
 }
 const IDENTITIES = new WeakMapWithPrimitives();
@@ -164,6 +154,7 @@ function uniqueKeyFor(keyFor) {
 }
 function createIteratorRef(listRef, key) {
   return createComputeRef(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let iterable = valueForRef(listRef),
       keyFor = function (key) {
         switch (key) {
@@ -205,10 +196,8 @@ class IteratorWrapper {
   }
 }
 class ArrayIterator {
-  current;
-  pos = 0;
   constructor(iterator, keyFor) {
-    this.iterator = iterator, this.keyFor = keyFor, 0 === iterator.length ? this.current = {
+    this.iterator = iterator, this.keyFor = keyFor, this.pos = 0, 0 === iterator.length ? this.current = {
       kind: "empty"
     } : this.current = {
       kind: "first",