ember-source 4.3.0-alpha.4 → 4.3.0-beta.1

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.4
+ * @version   4.3.0-beta.1
  */

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

@@ -124,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));
@@ -195,7 +195,7 @@ class Container {
 
   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);
@@ -352,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();
@@ -417,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 = {};
@@ -781,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) {
@@ -827,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) {
@@ -863,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,
@@ -882,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));
     }
   };
@@ -929,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

@@ -1505,7 +1505,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 +1893,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 +2006,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 +2070,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 +2150,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 +2186,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 +2447,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;
       }
@@ -4148,7 +4148,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));
@@ -4287,18 +4288,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
 
@@ -4558,14 +4555,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));
@@ -4587,7 +4584,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);
@@ -4595,7 +4593,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);
@@ -4604,9 +4606,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);
@@ -4627,7 +4634,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);
@@ -4652,7 +4659,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);
 
@@ -4744,7 +4752,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
@@ -4880,7 +4889,9 @@ var mut = internalHelper(({
 var readonly = internalHelper(({
   positional
 }) => {
-  return createReadOnlyRef(positional[0]);
+  let firstArg = positional[0];
+  assert('has first arg', firstArg);
+  return createReadOnlyRef(firstArg);
 });
 
 /**
@@ -4919,7 +4930,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'];
@@ -5138,6 +5149,7 @@ class ActionModifierManager {
       positional
     } = actionState;
     let actionNameRef = positional[1];
+    assert('Expected at least one positional arg', actionNameRef);
 
     if (!isInvokableRef(actionNameRef)) {
       actionState.actionName = valueForRef(actionNameRef);
@@ -5431,7 +5443,9 @@ const outletHelper = internalHelper((args, owner, scope) => {
   if (args.positional.length === 0) {
     nameRef = createPrimitiveRef('main');
   } else {
-    nameRef = args.positional[0];
+    let maybeNameRef = args.positional[0];
+    assert('Expected at least one positional arg', maybeNameRef);
+    nameRef = maybeNameRef;
   }
 
   let outletRef = createComputeRef(() => {
@@ -5871,8 +5885,8 @@ function deregister(renderer) {
 }
 
 function loopBegin() {
-  for (let i = 0; i < renderers.length; i++) {
-    renderers[i]._scheduleRevalidate();
+  for (let renderer of renderers) {
+    renderer._scheduleRevalidate();
   }
 }
 
@@ -5917,12 +5931,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');
       }
 
@@ -6045,6 +6059,7 @@ class Renderer {
 
     while (i--) {
       let root = roots[i];
+      assert('has root', root);
 
       if (root.isFor(view)) {
         root.destroy();
@@ -6116,6 +6131,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
@@ -6178,8 +6194,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;

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

@@ -685,8 +685,7 @@ function finishLazyChains(meta$$1, key, value) {
   }
 
   if (isObject(value)) {
-    for (let i = 0; i < lazyTags.length; i++) {
-      let [tag, deps] = lazyTags[i];
+    for (let [tag, deps] of lazyTags) {
       updateTag(tag, getChainTagsForKey(value, deps, tagMetaFor(value), peekMeta(value)));
     }
   }
@@ -696,8 +695,8 @@ function finishLazyChains(meta$$1, key, value) {
 function getChainTagsForKeys(obj, keys, tagMeta, meta$$1) {
   let tags = [];
 
-  for (let i = 0; i < keys.length; i++) {
-    getChainTags(tags, obj, keys[i], tagMeta, meta$$1);
+  for (let key of keys) {
+    getChainTags(tags, obj, key, tagMeta, meta$$1);
   }
 
   return combine(tags);
@@ -1313,8 +1312,8 @@ class ComputedProperty extends ComputedDescriptor {
       args.push(property);
     }
 
-    for (let i = 0; i < passedArgs.length; i++) {
-      expandProperties(passedArgs[i], addArg);
+    for (let arg of passedArgs) {
+      expandProperties(arg, addArg);
     }
 
     this._dependentKeys = args;
@@ -1603,13 +1602,16 @@ function computed(...args) {
   assert(`@computed can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: computed()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true));
 
   if (isElementDescriptor(args)) {
+    // SAFETY: We passed in the impl for this class
     let decorator = makeComputedDecorator(new ComputedProperty([]), ComputedDecoratorImpl);
     return decorator(args[0], args[1], args[2]);
-  }
+  } // SAFETY: We passed in the impl for this class
+
 
   return makeComputedDecorator(new ComputedProperty(args), ComputedDecoratorImpl);
 }
 function autoComputed(...config) {
+  // SAFETY: We passed in the impl for this class
   return makeComputedDecorator(new AutoComputedProperty(config), ComputedDecoratorImpl);
 }
 /**
@@ -1816,12 +1818,12 @@ function _getPath(root, path) {
   let obj = root;
   let parts = typeof path === 'string' ? path.split('.') : path;
 
-  for (let i = 0; i < parts.length; i++) {
+  for (let part of parts) {
     if (obj === undefined || obj === null || obj.isDestroyed) {
       return undefined;
     }
 
-    obj = _getProp(obj, parts[i]);
+    obj = _getProp(obj, part);
   }
 
   return obj;
@@ -1973,7 +1975,8 @@ function trySet(root, path, value) {
 }
 
 function alias(altKey) {
-  assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))); // SAFETY: We passed in the impl for this class
+
   return makeComputedDecorator(new AliasedProperty(altKey), AliasDecoratorImpl);
 } // TODO: This class can be svelted once `meta` has been deprecated
 
@@ -2312,11 +2315,10 @@ class Libraries {
 
   _getLibraryByName(name) {
     let libs = this._registry;
-    let count = libs.length;
 
-    for (let i = 0; i < count; i++) {
-      if (libs[i].name === name) {
-        return libs[i];
+    for (let lib of libs) {
+      if (lib.name === name) {
+        return lib;
       }
     }
 
@@ -2368,8 +2370,7 @@ if (DEBUG) {
     let maxNameLength = Math.max.apply(null, nameLengths);
     debug('-------------------------------');
 
-    for (let i = 0; i < libs.length; i++) {
-      let lib = libs[i];
+    for (let lib of libs) {
       let spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
       debug([lib.name, spaces, ' : ', lib.version].join(''));
     }
@@ -2434,10 +2435,8 @@ function setProperties(obj, properties) {
 
   changeProperties(() => {
     let props = Object.keys(properties);
-    let propertyName;
 
-    for (let i = 0; i < props.length; i++) {
-      propertyName = props[i];
+    for (let propertyName of props) {
       set(obj, propertyName, properties[propertyName]);
     }
   });
@@ -2484,9 +2483,8 @@ function findNamespaces() {
   let lookup = context.lookup;
   let keys = Object.keys(lookup);
 
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i]; // Only process entities that start with uppercase A-Z
-
+  for (let key of keys) {
+    // Only process entities that start with uppercase A-Z
     if (!isUppercase(key.charCodeAt(0))) {
       continue;
     }
@@ -2519,8 +2517,8 @@ function processAllNamespaces() {
   if (unprocessedNamespaces || unprocessedMixins) {
     let namespaces = NAMESPACES;
 
-    for (let i = 0; i < namespaces.length; i++) {
-      processNamespace(namespaces[i]);
+    for (let namespace of namespaces) {
+      processNamespace(namespace);
     }
 
     unprocessedMixins = false;
@@ -2596,10 +2594,7 @@ const {
 
 function extractAccessors(properties) {
   if (properties !== undefined) {
-    let keys = Object.keys(properties);
-
-    for (let i = 0; i < keys.length; i++) {
-      let key = keys[i];
+    for (let key of Object.keys(properties)) {
       let desc = Object.getOwnPropertyDescriptor(properties, key);
 
       if (desc.get !== undefined || desc.set !== undefined) {
@@ -2681,7 +2676,8 @@ function giveDecoratorSuper(key, decorator, property, descs) {
     }]);
     newProperty._readOnly = property._readOnly;
     newProperty._meta = property._meta;
-    newProperty.enumerable = property.enumerable;
+    newProperty.enumerable = property.enumerable; // SAFETY: We passed in the impl for this class
+
     return makeComputedDecorator(newProperty, ComputedProperty);
   }
 
@@ -2732,8 +2728,7 @@ function applyMergedProperties(key, value, values) {
   let hasFunction = false;
   let props = Object.keys(value);
 
-  for (let i = 0; i < props.length; i++) {
-    let prop = props[i];
+  for (let prop of props) {
     let propValue = value[prop];
 
     if (typeof propValue === 'function') {
@@ -2796,8 +2791,7 @@ function mergeProps(meta$$1, props, descs, values, base, keys, keysWithSuper) {
   let mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
   let propKeys = Object.keys(props);
 
-  for (let i = 0; i < propKeys.length; i++) {
-    let key = propKeys[i];
+  for (let key of propKeys) {
     let value = props[key];
     if (value === undefined) continue;
 
@@ -2860,16 +2854,16 @@ function updateObserversAndListeners(obj, key, fn, add) {
   if (observers !== undefined) {
     let updateObserver = add ? addObserver : removeObserver;
 
-    for (let i = 0; i < observers.paths.length; i++) {
-      updateObserver(obj, observers.paths[i], null, key, observers.sync);
+    for (let path of observers.paths) {
+      updateObserver(obj, path, null, key, observers.sync);
     }
   }
 
   if (listeners !== undefined) {
     let updateListener = add ? addListener : removeListener;
 
-    for (let i = 0; i < listeners.length; i++) {
-      updateListener(obj, listeners[i], null, key);
+    for (let listener of listeners) {
+      updateListener(obj, listener, null, key);
     }
   }
 }
@@ -2890,8 +2884,7 @@ function applyMixin(obj, mixins, _hideKeys = false) {
 
   mergeMixins(mixins, meta$$1, descs, values, obj, keys, keysWithSuper);
 
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i];
+  for (let key of keys) {
     let value = values[key];
     let desc = descs[key];
 
@@ -3288,8 +3281,8 @@ function observer(...args) {
   assert('observer called without sync', typeof sync === 'boolean');
   let paths = [];
 
-  for (let i = 0; i < dependentKeys.length; ++i) {
-    expandProperties(dependentKeys[i], path => paths.push(path));
+  for (let dependentKey of dependentKeys) {
+    expandProperties(dependentKey, path => paths.push(path));
   }
 
   setObservers(func, {
@@ -3307,8 +3300,14 @@ if (DEBUG) {
 
 function inject(type, ...args) {
   assert('a string type must be provided to inject', typeof type === 'string');
-  let calledAsDecorator = isElementDescriptor(args);
-  let name = calledAsDecorator ? undefined : args[0];
+  let elementDescriptor;
+  let name;
+
+  if (isElementDescriptor(args)) {
+    elementDescriptor = args;
+  } else if (typeof args[0] === 'string') {
+    name = args[0];
+  }
 
   let getInjection = function (propertyName) {
     let owner = getOwner(this) || this.container; // fallback to `container` for backwards compat
@@ -3333,8 +3332,8 @@ function inject(type, ...args) {
 
   });
 
-  if (calledAsDecorator) {
-    return decorator(args[0], args[1], args[2]);
+  if (elementDescriptor) {
+    return decorator(elementDescriptor[0], elementDescriptor[1], elementDescriptor[2]);
   } else {
     return decorator;
   }