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

package/dist/dependencies/@glimmer/owner.js

@@ -1,19 +1,16 @@
-import { symbol } from '@glimmer/util';
-
-const OWNER = symbol('OWNER');
+const OWNER = Symbol('OWNER');
 /**
   Framework objects in a Glimmer application may receive an owner object.
   Glimmer is unopinionated about this owner, but will forward it through its
   internal resolution system, and through its managers if it is provided.
 */
-
 function getOwner(object) {
   return object[OWNER];
 }
+
 /**
   `setOwner` set's an object's owner
 */
-
 function setOwner(object, owner) {
   object[OWNER] = owner;
 }

package/dist/dependencies/@glimmer/program.js

@@ -1,13 +1,13 @@
-import { constants, unwrapTemplate } from '@glimmer/util';
 import { getInternalHelperManager, getInternalModifierManager, getInternalComponentManager, capabilityFlagsFrom, getComponentTemplate, managerHasCapability } from '@glimmer/manager';
 import { templateFactory } from '@glimmer/opcode-compiler';
+import { constants, enumerate, assert, unwrapTemplate, expect, unwrap } from '@glimmer/util';
+import { InternalComponentCapabilities, OPERAND_LEN_MASK, ARG_SHIFT, MACHINE_MASK, TYPE_MASK } from '@glimmer/vm';
+import { SexpOpcodes } from '@glimmer/wire-format';
 
 /**
  * Default component template, which is a plain yield
  */
-const DEFAULT_TEMPLATE_BLOCK = [[[18
-/* Yield */
-, 1, null]], ['&default'], false, []];
+const DEFAULT_TEMPLATE_BLOCK = [[[SexpOpcodes.Yield, 1, null]], ['&default'], false, []];
 const DEFAULT_TEMPLATE = {
   // random uuid
   id: '1b32f5c2-7623-43d6-a0ad-9672898920a1',
@@ -21,113 +21,91 @@ const WELL_KNOWN_EMPTY_ARRAY = Object.freeze([]);
 const STARTER_CONSTANTS = constants(WELL_KNOWN_EMPTY_ARRAY);
 const WELL_KNOWN_EMPTY_ARRAY_POSITION = STARTER_CONSTANTS.indexOf(WELL_KNOWN_EMPTY_ARRAY);
 class CompileTimeConstantImpl {
-  constructor() {
-    // `0` means NULL
-    this.values = STARTER_CONSTANTS.slice();
-    this.indexMap = new Map(this.values.map((value, index) => [value, index]));
-  }
+  // `0` means NULL
 
+  values = STARTER_CONSTANTS.slice();
+  indexMap = new Map(this.values.map((value, index) => [value, index]));
   value(value) {
     let indexMap = this.indexMap;
     let index = indexMap.get(value);
-
     if (index === undefined) {
       index = this.values.push(value) - 1;
       indexMap.set(value, index);
     }
-
     return index;
   }
-
   array(values) {
     if (values.length === 0) {
       return WELL_KNOWN_EMPTY_ARRAY_POSITION;
     }
-
     let handles = new Array(values.length);
-
     for (let i = 0; i < values.length; i++) {
       handles[i] = this.value(values[i]);
     }
-
     return this.value(handles);
   }
-
   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);
     let reified = new Array(handles.length);
-
-    for (let i = 0; i < handles.length; i++) {
-      let n = handles[i];
+    for (const [i, n] of enumerate(handles)) {
       reified[i] = this.getValue(n);
     }
-
     return reified;
   }
-
 }
 class ConstantsImpl extends CompileTimeConstantImpl {
-  constructor() {
-    super(...arguments);
-    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.helperDefinitionCache = new WeakMap();
-    this.modifierDefinitionCache = new WeakMap();
-    this.componentDefinitionCache = new WeakMap();
-  }
-
-  helper(definitionState, // TODO: Add a way to expose resolved name for debugging
-  _resolvedName = null, isOptional) {
+  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) {
+    let isOptional = arguments.length > 2 ? arguments[2] : undefined;
     let handle = this.helperDefinitionCache.get(definitionState);
-
     if (handle === undefined) {
       let managerOrHelper = getInternalHelperManager(definitionState, isOptional);
-
       if (managerOrHelper === null) {
         this.helperDefinitionCache.set(definitionState, null);
         return null;
       }
+      assert(managerOrHelper, 'BUG: expected manager or helper');
       let helper = typeof managerOrHelper === 'function' ? managerOrHelper : managerOrHelper.getHelper(definitionState);
       handle = this.value(helper);
       this.helperDefinitionCache.set(definitionState, handle);
       this.helperDefinitionCount++;
     }
-
     return handle;
   }
-
-  modifier(definitionState, resolvedName = null, isOptional) {
+  modifier(definitionState) {
+    let resolvedName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let isOptional = arguments.length > 2 ? arguments[2] : undefined;
     let handle = this.modifierDefinitionCache.get(definitionState);
-
     if (handle === undefined) {
       let manager = getInternalModifierManager(definitionState, isOptional);
-
       if (manager === null) {
         this.modifierDefinitionCache.set(definitionState, null);
         return null;
       }
-
       let definition = {
         resolvedName,
         manager,
@@ -137,45 +115,34 @@ class ConstantsImpl extends CompileTimeConstantImpl {
       this.modifierDefinitionCache.set(definitionState, handle);
       this.modifierDefinitionCount++;
     }
-
     return handle;
   }
-
   component(definitionState, owner, isOptional) {
-    var _a;
-
     let definition = this.componentDefinitionCache.get(definitionState);
-
     if (definition === undefined) {
       let manager = getInternalComponentManager(definitionState, isOptional);
-
       if (manager === null) {
         this.componentDefinitionCache.set(definitionState, null);
         return null;
       }
+      assert(manager, 'BUG: expected manager');
       let capabilities = capabilityFlagsFrom(manager.getCapabilities(definitionState));
       let templateFactory = getComponentTemplate(definitionState);
       let compilable = null;
       let template;
-
-      if (!managerHasCapability(manager, capabilities, 1
-      /* DynamicLayout */
-      )) {
-        template = (_a = templateFactory === null || templateFactory === void 0 ? void 0 : templateFactory(owner)) !== null && _a !== void 0 ? _a : this.defaultTemplate;
+      if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) {
+        template = templateFactory?.(owner) ?? this.defaultTemplate;
       } else {
-        template = templateFactory === null || templateFactory === void 0 ? void 0 : templateFactory(owner);
+        template = templateFactory?.(owner);
       }
-
       if (template !== undefined) {
         template = unwrapTemplate(template);
-        compilable = managerHasCapability(manager, capabilities, 1024
-        /* Wrapped */
-        ) ? template.asWrappedLayout() : template.asLayout();
+        compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout();
       }
-
       definition = {
         resolvedName: null,
         handle: -1,
+        // replaced momentarily
         manager,
         capabilities,
         state: definitionState,
@@ -185,13 +152,10 @@ class ConstantsImpl extends CompileTimeConstantImpl {
       this.componentDefinitionCache.set(definitionState, definition);
       this.componentDefinitionCount++;
     }
-
     return definition;
   }
-
   resolvedComponent(resolvedDefinition, resolvedName) {
     let definition = this.componentDefinitionCache.get(resolvedDefinition);
-
     if (definition === undefined) {
       let {
         manager,
@@ -200,23 +164,17 @@ class ConstantsImpl extends CompileTimeConstantImpl {
       } = resolvedDefinition;
       let capabilities = capabilityFlagsFrom(manager.getCapabilities(resolvedDefinition));
       let compilable = null;
-
-      if (!managerHasCapability(manager, capabilities, 1
-      /* DynamicLayout */
-      )) {
-        template = template !== null && template !== void 0 ? template : this.defaultTemplate;
+      if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) {
+        template = template ?? this.defaultTemplate;
       }
-
       if (template !== null) {
         template = unwrapTemplate(template);
-        compilable = managerHasCapability(manager, capabilities, 1024
-        /* Wrapped */
-        ) ? template.asWrappedLayout() : template.asLayout();
+        compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout();
       }
-
       definition = {
         resolvedName,
         handle: -1,
+        // replaced momentarily
         manager,
         capabilities,
         state,
@@ -226,78 +184,65 @@ class ConstantsImpl extends CompileTimeConstantImpl {
       this.componentDefinitionCache.set(resolvedDefinition, definition);
       this.componentDefinitionCount++;
     }
-
-    return definition;
+    return expect(definition, 'BUG: resolved component definitions cannot be null');
   }
-
   getValue(index) {
+    assert(index >= 0, `cannot get value for handle: ${index}`);
     return this.values[index];
   }
-
   getArray(index) {
     let reifiedArrs = this.reifiedArrs;
     let reified = reifiedArrs[index];
-
     if (reified === undefined) {
       let names = this.getValue(index);
       reified = new Array(names.length);
-
-      for (let i = 0; i < names.length; i++) {
-        reified[i] = this.getValue(names[i]);
+      for (const [i, name] of enumerate(names)) {
+        reified[i] = this.getValue(name);
       }
-
       reifiedArrs[index] = reified;
     }
-
     return reified;
   }
-
 }
 
 class RuntimeOpImpl {
+  offset = 0;
   constructor(heap) {
     this.heap = heap;
-    this.offset = 0;
   }
-
   get size() {
     let rawType = this.heap.getbyaddr(this.offset);
-    return ((rawType & 768
-    /* OPERAND_LEN_MASK */
-    ) >> 8
-    /* ARG_SHIFT */
-    ) + 1;
+    return ((rawType & OPERAND_LEN_MASK) >> ARG_SHIFT) + 1;
   }
-
   get isMachine() {
     let rawType = this.heap.getbyaddr(this.offset);
-    return rawType & 1024
-    /* MACHINE_MASK */
-    ? 1 : 0;
+    return rawType & MACHINE_MASK ? 1 : 0;
   }
-
   get type() {
-    return this.heap.getbyaddr(this.offset) & 255
-    /* TYPE_MASK */
-    ;
+    return this.heap.getbyaddr(this.offset) & TYPE_MASK;
   }
-
   get op1() {
     return this.heap.getbyaddr(this.offset + 1);
   }
-
   get op2() {
     return this.heap.getbyaddr(this.offset + 2);
   }
-
   get op3() {
     return this.heap.getbyaddr(this.offset + 3);
   }
-
 }
 
+var TableSlotState = /*#__PURE__*/function (TableSlotState) {
+  TableSlotState[TableSlotState["Allocated"] = 0] = "Allocated";
+  TableSlotState[TableSlotState["Freed"] = 1] = "Freed";
+  TableSlotState[TableSlotState["Purged"] = 2] = "Purged";
+  TableSlotState[TableSlotState["Pointer"] = 3] = "Pointer";
+  return TableSlotState;
+}(TableSlotState || {});
 const PAGE_SIZE = 0x100000;
 class RuntimeHeapImpl {
+  heap;
+  table;
   constructor(serializedHeap) {
     let {
       buffer,
@@ -305,27 +250,25 @@ class RuntimeHeapImpl {
     } = serializedHeap;
     this.heap = new Int32Array(buffer);
     this.table = table;
-  } // It is illegal to close over this address, as compaction
+  }
+
+  // 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 this.table[handle];
+    return unwrap(this.table[handle]);
   }
-
   getbyaddr(address) {
-    return this.heap[address];
+    return expect(this.heap[address], 'Access memory out of bounds of the heap');
   }
-
   sizeof(handle) {
     return sizeof(this.table);
   }
-
 }
 function hydrateHeap(serializedHeap) {
   return new RuntimeHeapImpl(serializedHeap);
 }
+
 /**
  * The Heap is responsible for dynamically allocating
  * memory in which we read/write the VM's instructions
@@ -346,70 +289,67 @@ 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;
   constructor() {
-    this.offset = 0;
-    this.handle = 0;
     this.heap = new Int32Array(PAGE_SIZE);
     this.handleTable = [];
     this.handleState = [];
   }
-
-  push(item) {
+  pushRaw(value) {
     this.sizeCheck();
-    this.heap[this.offset++] = item;
+    this.heap[this.offset++] = value;
+  }
+  pushOp(item) {
+    this.pushRaw(item);
+  }
+  pushMachine(item) {
+    this.pushRaw(item | MACHINE_MASK);
   }
-
   sizeCheck() {
     let {
       heap
     } = this;
-
     if (this.offset === this.heap.length) {
       let newHeap = new Int32Array(heap.length + PAGE_SIZE);
       newHeap.set(heap, 0);
       this.heap = newHeap;
     }
   }
-
   getbyaddr(address) {
-    return this.heap[address];
+    return unwrap(this.heap[address]);
   }
-
   setbyaddr(address, value) {
     this.heap[address] = value;
   }
-
   malloc() {
     // push offset, info, size
     this.handleTable.push(this.offset);
     return this.handleTable.length - 1;
   }
-
   finishMalloc(handle) {
   }
-
   size() {
     return this.offset;
-  } // It is illegal to close over this address, as compaction
+  }
+
+  // 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 this.handleTable[handle];
+    return unwrap(this.handleTable[handle]);
   }
-
   sizeof(handle) {
     return sizeof(this.handleTable);
   }
-
   free(handle) {
-    this.handleState[handle] = 1
-    /* Freed */
-    ;
+    this.handleState[handle] = TableSlotState.Freed;
   }
+
   /**
    * The heap uses the [Mark-Compact Algorithm](https://en.wikipedia.org/wiki/Mark-compact_algorithm) to shift
    * reachable memory to the bottom of the heap and freeable
@@ -417,8 +357,6 @@ class HeapImpl {
    * the reachable memory to the top of the heap, we move the
    * offset to the next free position.
    */
-
-
   compact() {
     let compactedSize = 0;
     let {
@@ -426,45 +364,31 @@ class HeapImpl {
       handleState,
       heap
     } = this;
-
     for (let i = 0; i < length; i++) {
-      let offset = handleTable[i];
-      let size = handleTable[i + 1] - offset;
+      let offset = unwrap(handleTable[i]);
+      let size = unwrap(handleTable[i + 1]) - unwrap(offset);
       let state = handleState[i];
-
-      if (state === 2
-      /* Purged */
-      ) {
-          continue;
-        } else if (state === 1
-      /* Freed */
-      ) {
-          // transition to "already freed" aka "purged"
-          // a good improvement would be to reuse
-          // these slots
-          handleState[i] = 2
-          /* Purged */
-          ;
-          compactedSize += size;
-        } else if (state === 0
-      /* Allocated */
-      ) {
-          for (let j = offset; j <= i + size; j++) {
-            heap[j - compactedSize] = heap[j];
-          }
-
-          handleTable[i] = offset - compactedSize;
-        } else if (state === 3
-      /* Pointer */
-      ) {
-          handleTable[i] = offset - compactedSize;
+      if (state === TableSlotState.Purged) {
+        continue;
+      } else if (state === TableSlotState.Freed) {
+        // 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]);
         }
+        handleTable[i] = offset - compactedSize;
+      } else if (state === TableSlotState.Pointer) {
+        handleTable[i] = offset - compactedSize;
+      }
     }
-
     this.offset = this.offset - compactedSize;
   }
-
-  capture(offset = this.offset) {
+  capture() {
+    let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.offset;
     // Only called in eager mode
     let buffer = slice(this.heap, 0, offset).buffer;
     return {
@@ -473,36 +397,29 @@ class HeapImpl {
       buffer: buffer
     };
   }
-
 }
 class RuntimeProgramImpl {
+  _opcode;
   constructor(constants, heap) {
     this.constants = constants;
     this.heap = heap;
     this._opcode = new RuntimeOpImpl(this.heap);
   }
-
   opcode(offset) {
     this._opcode.offset = offset;
     return this._opcode;
   }
-
 }
-
 function slice(arr, start, end) {
   if (arr.slice !== undefined) {
     return arr.slice(start, end);
   }
-
   let ret = new Int32Array(end);
-
   for (; start < end; start++) {
-    ret[start] = arr[start];
+    ret[start] = unwrap(arr[start]);
   }
-
   return ret;
 }
-
 function sizeof(table, handle) {
   {
     return -1;