ember-source 4.3.0-alpha.3 → 4.4.0-alpha.2

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.3.0-alpha.3
+ * @version   4.4.0-alpha.2
  */

package/dist/packages/@ember/-internals/container/index.js

@@ -18,6 +18,7 @@ if (DEBUG) {
         containers = new WeakSet();
         return {
           hasContainers() {
+            // @ts-expect-error We just checked if it is definied
             gc();
             return GetWeakSetValues(containers).length > 0;
           },
@@ -123,7 +124,7 @@ class Container {
 
   lookup(fullName, options) {
     if (this.isDestroyed) {
-      throw new Error(`Can not call \`.lookup\` after the owner has been destroyed`);
+      throw new Error(`Cannot call \`.lookup\` after the owner has been destroyed`);
     }
 
     assert('fullName must be a proper full name', this.registry.isValidFullName(fullName));
@@ -186,19 +187,19 @@ class Container {
     @public
    @method factoryFor
    @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
 
 
   factoryFor(fullName) {
     if (this.isDestroyed) {
-      throw new Error(`Can not call \`.factoryFor\` after the owner has been destroyed`);
+      throw new Error(`Cannot call \`.factoryFor\` after the owner has been destroyed`);
     }
 
     let normalizedName = this.registry.normalize(fullName);
-    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
+    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)); // TODO: This needs to return a Factory to be compatible with Owner.
+    // We should correctly the types so that this cast is not necessary.
+
     return factoryFor(this, normalizedName, fullName);
   }
 
@@ -351,9 +352,9 @@ function destroyDestroyables(container) {
   let cache = container.cache;
   let keys = Object.keys(cache);
 
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i];
+  for (let key of keys) {
     let value = cache[key];
+    assert('has cached value', value);
 
     if (value.destroy) {
       value.destroy();
@@ -416,7 +417,7 @@ class FactoryManager {
     } = this;
 
     if (container.isDestroyed) {
-      throw new Error(`Can not create new instances after the owner has been destroyed (you attempted to create ${this.fullName})`);
+      throw new Error(`Cannot create new instances after the owner has been destroyed (you attempted to create ${this.fullName})`);
     }
 
     let props = {};
@@ -780,6 +781,8 @@ class Registry {
     }
 
     let type = fullName.split(':')[0];
+    assert('has type', type); // split always will have at least one value
+
     options = this._typeOptions[type];
 
     if (options && options[optionName] !== undefined) {
@@ -826,8 +829,7 @@ class Registry {
     let localKnown = dictionary(null);
     let registeredNames = Object.keys(this.registrations);
 
-    for (let index = 0; index < registeredNames.length; index++) {
-      let fullName = registeredNames[index];
+    for (let fullName of registeredNames) {
       let itemType = fullName.split(':')[0];
 
       if (itemType === type) {
@@ -862,9 +864,11 @@ if (DEBUG) {
 
     for (let key in hash) {
       if (Object.prototype.hasOwnProperty.call(hash, key)) {
+        let value = hash[key];
+        assert('has value', value);
         let {
           specifier
-        } = hash[key];
+        } = value;
         assert(`Expected a proper full name, given '${specifier}'`, this.isValidFullName(specifier));
         injections.push({
           property: key,
@@ -881,10 +885,10 @@ if (DEBUG) {
       return;
     }
 
-    for (let i = 0; i < injections.length; i++) {
+    for (let injection of injections) {
       let {
         specifier
-      } = injections[i];
+      } = injection;
       assert(`Attempting to inject an unknown injection: '${specifier}'`, this.has(specifier));
     }
   };
@@ -928,6 +932,7 @@ function has(registry, fullName) {
 const privateNames = dictionary(null);
 const privateSuffix = `${Math.random()}${Date.now()}`.replace('.', '');
 function privatize([fullName]) {
+  assert('has a single string argument', arguments.length === 1 && fullName);
   let name = privateNames[fullName];
 
   if (name) {

package/dist/packages/@ember/-internals/glimmer/index.js

@@ -9,8 +9,9 @@ import { untrack, consumeTag, createCache, getValue, tagFor, beginUntrackFrame,
 import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, set, _getProp, _setProp } from '@ember/-internals/metal';
 import { action } from '@ember/object';
 import { hasDOM } from '@ember/-internals/browser-environment';
-import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
+import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, EventDispatcher, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
 import { getEngineParent } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 import { flaggedInstrument, _instrumentStart } from '@ember/instrumentation';
 import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
@@ -1099,11 +1100,13 @@ class LinkTo extends InternalComponent {
   }
 
   get isEngine() {
-    return getEngineParent(this.owner) !== undefined;
+    let owner = this.owner;
+    return owner instanceof EngineInstance && getEngineParent(owner) !== undefined;
   }
 
   get engineMountPoint() {
-    return this.owner.mountPoint;
+    let owner = this.owner;
+    return owner instanceof EngineInstance ? owner.mountPoint : undefined;
   }
 
   classFor(state) {
@@ -1505,7 +1508,11 @@ function installAttributeBinding(component, rootRef, parsed, operations) {
   operations.setAttribute(attribute, reference, false, null);
 }
 function createClassNameBindingRef(rootRef, microsyntax, operations) {
-  let [prop, truthy, falsy] = microsyntax.split(':');
+  let parts = microsyntax.split(':');
+  let [prop, truthy, falsy] = parts; // NOTE: This could be an empty string
+
+  assert('has prop', prop !== undefined); // Will always have at least one part
+
   let isStatic = prop === '';
 
   if (isStatic) {
@@ -1889,9 +1896,10 @@ var action$1 = internalHelper(args => {
   // Anything else is an action argument.
 
   let [context, action$$1, ...restArgs] = positional;
+  assert('hash position arguments', context && action$$1);
   let debugKey = action$$1.debugLabel;
-  let target = 'target' in named ? named.target : context;
-  let processArgs = makeArgsProcessor('value' in named && named.value, restArgs);
+  let target = 'target' in named && named.target ? named.target : context;
+  let processArgs = makeArgsProcessor('value' in named && named.value || false, restArgs);
   let fn$$1;
 
   if (isInvokableRef(action$$1)) {
@@ -2001,6 +2009,7 @@ function processComponentArgs(namedArgs) {
 
   for (let name in namedArgs) {
     let ref = namedArgs[name];
+    assert('expected ref', ref);
     let value = valueForRef(ref);
     let isAction = typeof value === 'function' && ACTIONS.has(value);
 
@@ -2064,6 +2073,7 @@ function applyAttributeBindings(attributeBindings, component, rootRef, operation
 
   while (i !== -1) {
     let binding = attributeBindings[i];
+    assert('has binding', binding);
     let parsed = parseAttributeBinding(binding);
     let attribute = parsed[1];
 
@@ -2143,8 +2153,9 @@ class CurlyComponentManager {
           {
         __ARGS__
       } = _b,
-          rest = __rest(_b, ["__ARGS__"]); // does this need to be untracked?
+          rest = __rest(_b, ["__ARGS__"]);
 
+      assert('[BUG] unexpectedly missing __ARGS__ after check', __ARGS__); // does this need to be untracked?
 
       let __args__ = valueForRef(__ARGS__);
 
@@ -2178,14 +2189,8 @@ class CurlyComponentManager {
       Object.assign(named, args.named.capture());
 
       for (let i = 0; i < count; i++) {
-        // As of TS 3.7, tsc is giving us the following error on this line without the type annotation
-        //
-        //   TS7022: 'name' implicitly has type 'any' because it does not have a type annotation and is
-        //   referenced directly or indirectly in its own initializer.
-        //
-        // This is almost certainly a TypeScript bug, feel free to try and remove the annotation after
-        // upgrading if it is not needed anymore.
-        const name = positionalParams[i];
+        let name = positionalParams[i];
+        assert('Expected at least one positional param', name);
         assert(`You cannot specify both a positional param (at position ${i}) and the hash argument \`${name}\`.`, !args.named.has(name));
         named[name] = args.positional.at(i);
       }
@@ -2445,9 +2450,7 @@ function processComponentInitializationAssertions(component, props) {
       classNameBindings
     } = component;
 
-    for (let i = 0; i < classNameBindings.length; i++) {
-      let binding = classNameBindings[i];
-
+    for (let binding of classNameBindings) {
       if (binding.split(' ').length > 1) {
         return false;
       }
@@ -3165,6 +3168,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
 
       if (owner.lookup('-environment:main').isInteractive) {
         this.__dispatcher = owner.lookup('event_dispatcher:main');
+        assert('Expected dispatcher to be an EventDispatcher', this.__dispatcher instanceof EventDispatcher);
       } else {
         // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
         this.__dispatcher = null;
@@ -3406,6 +3410,59 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
    @since 1.13.0
    */
   didUpdate() {}
+  /**
+   Called when the component has updated and rerendered itself.
+   Called only during a rerender, not during an initial render.
+   @event didUpdate
+   @public
+   @since 1.13.0
+   */
+
+  /**
+    Layout can be used to wrap content in a component.
+    @property layout
+    @type Function
+    @public
+  */
+
+  /**
+    The name of the layout to lookup if no layout is provided.
+    By default `Component` will lookup a template with this name in
+    `Ember.TEMPLATES` (a shared global object).
+    @property layoutName
+    @type String
+    @default null
+    @private
+  */
+
+  /**
+    The HTML `id` of the component's element in the DOM. You can provide this
+    value yourself but it must be unique (just as in HTML):
+     ```handlebars
+    {{my-component elementId="a-really-cool-id"}}
+    ```
+     ```handlebars
+    <MyComponent @elementId="a-really-cool-id" />
+    ```
+    If not manually set a default value will be provided by the framework.
+    Once rendered an element's `elementId` is considered immutable and you
+    should never change it. If you need to compute a dynamic value for the
+    `elementId`, you should do this when the component or element is being
+    instantiated:
+     ```javascript
+    export default Component.extend({
+      init() {
+        this._super(...arguments);
+         var index = this.get('index');
+        this.set('elementId', `component-id${index}`);
+      }
+    });
+    ```
+     @property elementId
+    @type String
+    @public
+  */
+
 
 });
 
@@ -3734,11 +3791,9 @@ class OutletComponentManager {
       let currentOwner = valueForRef(currentStateRef).render.owner;
 
       if (parentOwner && parentOwner !== currentOwner) {
-        let engine = currentOwner;
-        assert('invalid engine: missing mountPoint', typeof currentOwner.mountPoint === 'string');
-        assert('invalid engine: missing routable', currentOwner.routable === true);
-        let mountPoint = engine.mountPoint;
-        state.engine = engine;
+        assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance);
+        let mountPoint = currentOwner.mountPoint;
+        state.engine = currentOwner;
         state.engineBucket = {
           mountPoint
         };
@@ -4095,7 +4150,8 @@ class EachInWrapper {
 var eachIn = internalHelper(({
   positional
 }) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
   return createComputeRef(() => {
     let iterable = valueForRef(inner);
     consumeTag(tagForObject(iterable));
@@ -4234,18 +4290,14 @@ class ObjectIterator extends BoundedIterator {
 
   static fromIndexable(obj) {
     let keys = Object.keys(obj);
-    let {
-      length
-    } = keys;
 
-    if (length === 0) {
+    if (keys.length === 0) {
       return null;
     } else {
       let values = [];
 
-      for (let i = 0; i < length; i++) {
+      for (let key of keys) {
         let value;
-        let key = keys[i];
         value = obj[key]; // Add the tag of the returned value if it is an array, since arrays
         // should always cause updates if they are consumed and then changed
 
@@ -4505,14 +4557,14 @@ var disallowDynamicResolution = internalHelper(({
   positional,
   named
 }) => {
-  assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1);
-  let nameOrValueRef = positional[0];
-  assert(`[BUG] expecting \`type\` named argument`, 'type' in named);
-  assert(`[BUG] expecting \`loc\` named argument`, 'loc' in named);
-  assert(`[BUG] expecting \`original\` named argument`, 'original' in named);
+  const nameOrValueRef = positional[0];
+  assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef);
   let typeRef = named.type;
   let locRef = named.loc;
-  let originalRef = named.original; // Bug: why do these fail?
+  let originalRef = named.original;
+  assert(`[BUG] expecting \`type\` named argument`, typeRef);
+  assert(`[BUG] expecting \`loc\` named argument`, locRef);
+  assert(`[BUG] expecting \`original\` named argument`, originalRef); // Bug: why do these fail?
   // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
   // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));
   // assert('[BUG] expecting a string literal for the `original` argument', isConstRef(originalRef));
@@ -4525,7 +4577,7 @@ var disallowDynamicResolution = internalHelper(({
   assert('[BUG] expecting a string literal for the `original` argument', typeof original === 'string');
   return createComputeRef(() => {
     let nameOrValue = valueForRef(nameOrValueRef);
-    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them to the ${type} keyword. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
+    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them directly. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
     return nameOrValue;
   });
 });
@@ -4534,7 +4586,8 @@ let helper$1;
 
 if (DEBUG) {
   helper$1 = args => {
-    let inner = args.positional[0];
+    const inner = args.positional[0];
+    assert('expected at least one positional arg', inner);
     return createComputeRef(() => {
       let value = valueForRef(inner);
       assert('You cannot pass a null or undefined destination element to in-element', value !== null && value !== undefined);
@@ -4542,7 +4595,11 @@ if (DEBUG) {
     });
   };
 } else {
-  helper$1 = args => args.positional[0];
+  helper$1 = args => {
+    let arg = args.positional[0];
+    assert('expected at least one positional arg', arg);
+    return arg;
+  };
 }
 
 var inElementNullCheckHelper = internalHelper(helper$1);
@@ -4551,9 +4608,14 @@ var normalizeClassHelper = internalHelper(({
   positional
 }) => {
   return createComputeRef(() => {
-    let classNameParts = valueForRef(positional[0]).split('.');
+    let classNameArg = positional[0];
+    let valueArg = positional[1];
+    assert('expected at least two positional args', classNameArg && valueArg);
+    let classNameParts = valueForRef(classNameArg).split('.');
     let className = classNameParts[classNameParts.length - 1];
-    let value = valueForRef(positional[1]);
+    assert('has className', className); // Always at least one split result
+
+    let value = valueForRef(valueArg);
 
     if (value === true) {
       return dasherize(className);
@@ -4574,7 +4636,7 @@ var resolve = internalHelper(({
   assert('[BUG] missing owner', owner);
   assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1);
   let fullNameRef = positional[0];
-  assert('[BUG] expecting a string literal as argument', isConstRef(fullNameRef));
+  assert('[BUG] expecting a string literal as argument', fullNameRef && isConstRef(fullNameRef));
   let fullName = valueForRef(fullNameRef);
   assert('[BUG] expecting a string literal as argument', typeof fullName === 'string');
   assert('[BUG] expecting a valid full name', fullName.split(':').length === 2);
@@ -4599,7 +4661,8 @@ var resolve = internalHelper(({
 var trackArray = internalHelper(({
   positional
 }) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
   return createComputeRef(() => {
     let iterable = valueForRef(inner);
 
@@ -4691,7 +4754,8 @@ var trackArray = internalHelper(({
 var mut = internalHelper(({
   positional
 }) => {
-  let ref = positional[0]; // TODO: Improve this error message. This covers at least two distinct
+  let ref = positional[0];
+  assert('expected at least one positional arg', ref); // TODO: Improve this error message. This covers at least two distinct
   // cases:
   //
   // 1. (mut "not a path") – passing a literal, result from a helper
@@ -4827,7 +4891,9 @@ var mut = internalHelper(({
 var readonly = internalHelper(({
   positional
 }) => {
-  return createReadOnlyRef(positional[0]);
+  let firstArg = positional[0];
+  assert('has first arg', firstArg);
+  return createReadOnlyRef(firstArg);
 });
 
 /**
@@ -4866,7 +4932,7 @@ var unbound = internalHelper(({
   named
 }) => {
   assert('unbound helper cannot be called with multiple params or hash params', positional.length === 1 && Object.keys(named).length === 0);
-  return createUnboundRef(valueForRef(positional[0]), '(resurt of an `unbound` helper)');
+  return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
 });
 
 const MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
@@ -5085,6 +5151,7 @@ class ActionModifierManager {
       positional
     } = actionState;
     let actionNameRef = positional[1];
+    assert('Expected at least one positional arg', actionNameRef);
 
     if (!isInvokableRef(actionNameRef)) {
       actionState.actionName = valueForRef(actionNameRef);
@@ -5100,6 +5167,7 @@ class ActionModifierManager {
 
   ensureEventSetup(actionState) {
     let dispatcher = actionState.owner.lookup('event_dispatcher:main');
+    assert('Expected dispatcher to be an EventDispatcher', dispatcher instanceof EventDispatcher);
     dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.setupHandlerForEmberEvent(actionState.eventName);
   }
 
@@ -5153,6 +5221,7 @@ class MountManager {
     // mount is a runtime helper, this shouldn't use dynamic layout
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
+    assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance);
     let engine = owner.buildChildEngineInstance(name);
     engine.boot();
     let applicationFactory = engine.factoryFor(`controller:application`);
@@ -5365,26 +5434,17 @@ const mountHelper = internalHelper((args, owner) => {
   Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
 
   @method outlet
-  @param {String} [name]
   @for Ember.Templates.helpers
   @public
 */
 
-const outletHelper = internalHelper((args, owner, scope) => {
+const outletHelper = internalHelper((_args, owner, scope) => {
   assert('Expected owner to be present, {{outlet}} requires an owner', owner);
   assert('Expected dynamic scope to be present. You may have attempted to use the {{outlet}} keyword dynamically. This keyword cannot be used dynamically.', scope);
-  let nameRef;
-
-  if (args.positional.length === 0) {
-    nameRef = createPrimitiveRef('main');
-  } else {
-    nameRef = args.positional[0];
-  }
-
   let outletRef = createComputeRef(() => {
     let state = valueForRef(scope.get('outletState'));
     let outlets = state !== undefined ? state.outlets : undefined;
-    return outlets !== undefined ? outlets[valueForRef(nameRef)] : undefined;
+    return outlets !== undefined ? outlets.main : undefined;
   });
   let lastState = null;
   let definition = null;
@@ -5474,9 +5534,9 @@ function instrumentationPayload$1(name) {
   };
 }
 
-function componentFor(name, owner, options) {
+function componentFor(name, owner) {
   let fullName = `component:${name}`;
-  return owner.factoryFor(fullName, options) || null;
+  return owner.factoryFor(fullName) || null;
 }
 
 function layoutFor(name, owner, options) {
@@ -5485,7 +5545,7 @@ function layoutFor(name, owner, options) {
 }
 
 function lookupComponentPair(owner, name, options) {
-  let component = componentFor(name, owner, options);
+  let component = componentFor(name, owner);
 
   if (component !== null && component.class !== undefined) {
     let layout = getComponentTemplate(component.class);
@@ -5818,8 +5878,8 @@ function deregister(renderer) {
 }
 
 function loopBegin() {
-  for (let i = 0; i < renderers.length; i++) {
-    renderers[i]._scheduleRevalidate();
+  for (let renderer of renderers) {
+    renderer._scheduleRevalidate();
   }
 }
 
@@ -5864,12 +5924,12 @@ function resolveRenderPromise() {
 let loops = 0;
 
 function loopEnd() {
-  for (let i = 0; i < renderers.length; i++) {
-    if (!renderers[i]._isValid()) {
+  for (let renderer of renderers) {
+    if (!renderer._isValid()) {
       if (loops > ENV._RERENDER_LOOP_LIMIT) {
         loops = 0; // TODO: do something better
 
-        renderers[i].destroy();
+        renderer.destroy();
         throw new Error('infinite rendering invalidation detected');
       }
 
@@ -5992,6 +6052,7 @@ class Renderer {
 
     while (i--) {
       let root = roots[i];
+      assert('has root', root);
 
       if (root.isFor(view)) {
         root.destroy();
@@ -6063,6 +6124,7 @@ class Renderer {
         // each root is processed
         for (let i = 0; i < roots.length; i++) {
           let root = roots[i];
+          assert('has root', root);
 
           if (root.destroyed) {
             // add to the list of roots to be removed
@@ -6125,8 +6187,7 @@ class Renderer {
   _clearAllRoots() {
     let roots = this._roots;
 
-    for (let i = 0; i < roots.length; i++) {
-      let root = roots[i];
+    for (let root of roots) {
       root.destroy();
     }
 

package/dist/packages/@ember/-internals/meta/lib/meta.js

@@ -356,7 +356,8 @@ export class Meta {
         sync
       });
     } else {
-      let listener = listeners[i]; // If the listener is our own listener and we are trying to remove it, we
+      let listener = listeners[i];
+      assert('has listener', listener); // If the listener is our own listener and we are trying to remove it, we
       // want to splice it out entirely so we don't hold onto a reference.
 
       if (kind === 2
@@ -447,8 +448,7 @@ export class Meta {
               this._inheritedEnd = 0;
             }
 
-            for (let i = 0; i < parentListeners.length; i++) {
-              let listener = parentListeners[i];
+            for (let listener of parentListeners) {
               let index = indexOfListener(listeners, listener.event, listener.target, listener.method);
 
               if (index === -1) {
@@ -481,10 +481,9 @@ export class Meta {
     }
 
     if (listeners !== undefined) {
-      for (let index = 0; index < listeners.length; index++) {
-        let listener = listeners[index]; // REMOVE listeners are placeholders that tell us not to
+      for (let listener of listeners) {
+        // REMOVE listeners are placeholders that tell us not to
         // inherit, so they never match. Only ADD and ONCE can match.
-
         if (listener.event === eventName && (listener.kind === 0
         /* ADD */
         || listener.kind === 1
@@ -517,10 +516,9 @@ export class Meta {
     }
 
     if (listeners !== undefined) {
-      for (let index = 0; index < listeners.length; index++) {
-        let listener = listeners[index]; // REMOVE listeners are placeholders that tell us not to
+      for (let listener of listeners) {
+        // REMOVE listeners are placeholders that tell us not to
         // inherit, so they never match. Only ADD and ONCE can match.
-
         if ((listener.kind === 0
         /* ADD */
         || listener.kind === 1
@@ -642,6 +640,7 @@ export { counters };
 function indexOfListener(listeners, event, target, method) {
   for (let i = listeners.length - 1; i >= 0; i--) {
     let listener = listeners[i];
+    assert('has listener', listener);
 
     if (listener.event === event && listener.target === target && listener.method === method) {
       return i;