ember-source 4.4.0-alpha.6 → 4.4.0

package/dist/packages/@ember/-internals/runtime/lib/system/core_object.js

@@ -5,13 +5,22 @@ import { getFactoryFor, setFactoryFor } from '@ember/-internals/container';
 import { getOwner } from '@ember/-internals/owner';
 import { guidFor, makeArray, isInternalSymbol } from '@ember/-internals/utils';
 import { meta } from '@ember/-internals/meta';
-import { PROXY_CONTENT, sendEvent, Mixin, activateObserver, applyMixin, defineProperty, descriptorForProperty, isClassicDecorator, DEBUG_INJECTION_FUNCTIONS } from '@ember/-internals/metal';
+import { PROXY_CONTENT, sendEvent, Mixin, activateObserver, applyMixin, defineProperty, descriptorForProperty, isClassicDecorator, DEBUG_INJECTION_FUNCTIONS, hasUnknownProperty } from '@ember/-internals/metal';
 import ActionHandler from '../mixins/action_handler';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { _WeakSet as WeakSet } from '@glimmer/util';
 import { destroy, isDestroying, isDestroyed, registerDestructor } from '@glimmer/destroyable';
 import { OWNER } from '@glimmer/owner';
+
+function hasSetUnknownProperty(val) {
+  return typeof val === 'object' && val !== null && typeof val.setUnknownProperty === 'function';
+}
+
+function hasToStringExtension(val) {
+  return typeof val === 'object' && val !== null && typeof val.toStringExtension === 'function';
+}
+
 const reopen = Mixin.prototype.reopen;
 const wasApplied = new WeakSet();
 const prototypeMixinMap = new WeakMap();
@@ -33,12 +42,9 @@ function initialize(obj, properties) {
     assert('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof Mixin));
     let concatenatedProperties = obj.concatenatedProperties;
     let mergedProperties = obj.mergedProperties;
-    let hasConcatenatedProps = concatenatedProperties !== undefined && concatenatedProperties.length > 0;
-    let hasMergedProps = mergedProperties !== undefined && mergedProperties.length > 0;
     let keyNames = Object.keys(properties);
 
-    for (let i = 0; i < keyNames.length; i++) {
-      let keyName = keyNames[i];
+    for (let keyName of keyNames) {
       let value = properties[keyName];
       assert('EmberObject.create no longer supports defining computed ' + 'properties. Define computed properties using extend() or reopen() ' + 'before calling create().', !isClassicDecorator(value));
       assert('EmberObject.create no longer supports defining methods that call _super.', !(typeof value === 'function' && value.toString().indexOf('._super') !== -1));
@@ -47,7 +53,7 @@ function initialize(obj, properties) {
       let isDescriptor = possibleDesc !== undefined;
 
       if (!isDescriptor) {
-        if (hasConcatenatedProps && concatenatedProperties.indexOf(keyName) > -1) {
+        if (concatenatedProperties !== undefined && concatenatedProperties.length > 0 && concatenatedProperties.includes(keyName)) {
           let baseValue = obj[keyName];
 
           if (baseValue) {
@@ -57,7 +63,7 @@ function initialize(obj, properties) {
           }
         }
 
-        if (hasMergedProps && mergedProperties.indexOf(keyName) > -1) {
+        if (mergedProperties !== undefined && mergedProperties.length > 0 && mergedProperties.includes(keyName)) {
           let baseValue = obj[keyName];
           value = Object.assign({}, baseValue, value);
         }
@@ -65,7 +71,7 @@ function initialize(obj, properties) {
 
       if (isDescriptor) {
         possibleDesc.set(obj, keyName, value);
-      } else if (typeof obj.setUnknownProperty === 'function' && !(keyName in obj)) {
+      } else if (hasSetUnknownProperty(obj) && !(keyName in obj)) {
         obj.setUnknownProperty(keyName, value);
       } else {
         if (DEBUG) {
@@ -92,79 +98,17 @@ function initialize(obj, properties) {
     }
   }
 
-  sendEvent(obj, 'init', undefined, undefined, undefined, m);
+  sendEvent(obj, 'init', undefined, undefined, m);
 }
-/**
-  `CoreObject` is the base class for all Ember constructs. It establishes a
-  class system based on Ember's Mixin system, and provides the basis for the
-  Ember Object Model. `CoreObject` should generally not be used directly,
-  instead you should use `EmberObject`.
-
-  ## Usage
-
-  You can define a class by extending from `CoreObject` using the `extend`
-  method:
-
-  ```js
-  const Person = CoreObject.extend({
-    name: 'Tomster',
-  });
-  ```
-
-  For detailed usage, see the [Object Model](https://guides.emberjs.com/release/object-model/)
-  section of the guides.
-
-  ## Usage with Native Classes
-
-  Native JavaScript `class` syntax can be used to extend from any `CoreObject`
-  based class:
-
-  ```js
-  class Person extends CoreObject {
-    init() {
-      super.init(...arguments);
-      this.name = 'Tomster';
-    }
-  }
-  ```
-
-  Some notes about `class` usage:
-
-  * `new` syntax is not currently supported with classes that extend from
-    `EmberObject` or `CoreObject`. You must continue to use the `create` method
-    when making new instances of classes, even if they are defined using native
-    class syntax. If you want to use `new` syntax, consider creating classes
-    which do _not_ extend from `EmberObject` or `CoreObject`. Ember features,
-    such as computed properties and decorators, will still work with base-less
-    classes.
-  * Instead of using `this._super()`, you must use standard `super` syntax in
-    native classes. See the [MDN docs on classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Super_class_calls_with_super)
-    for more details.
-  * Native classes support using [constructors](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Constructor)
-    to set up newly-created instances. Ember uses these to, among other things,
-    support features that need to retrieve other entities by name, like Service
-    injection and `getOwner`. To ensure your custom instance setup logic takes
-    place after this important work is done, avoid using the `constructor` in
-    favor of `init`.
-  * Properties passed to `create` will be available on the instance by the time
-    `init` runs, so any code that requires these values should work at that
-    time.
-  * Using native classes, and switching back to the old Ember Object model is
-    fully supported.
-
-  @class CoreObject
-  @public
-*/
-
 
 class CoreObject {
   constructor(owner) {
     this[OWNER] = owner; // prepare prototype...
 
     this.constructor.proto();
-    let self = this;
+    let self;
 
-    if (DEBUG && typeof self.unknownProperty === 'function') {
+    if (DEBUG && hasUnknownProperty(this)) {
       let messageFor = (obj, property) => {
         return `You attempted to access the \`${String(property)}\` property (of ${obj}).\n` + `Since Ember 3.1, this is usually fine as you no longer need to use \`.get()\`\n` + `to access computed properties. However, in this case, the object in question\n` + `is a special kind of Ember object (a proxy). Therefore, it is still necessary\n` + `to use \`.get('${String(property)}')\` in this case.\n\n` + `If you encountered this error because of third-party code that you don't control,\n` + `there is more information at https://github.com/emberjs/ember.js/issues/16148, and\n` + `you can help us improve this error message by telling us more about what happened in\n` + `this situation.`;
       };
@@ -188,10 +132,13 @@ class CoreObject {
         }
 
       });
+    } else {
+      self = this;
     }
 
+    const destroyable = self;
     registerDestructor(self, ensureDestroyCalled, true);
-    registerDestructor(self, () => self.willDestroy()); // disable chains
+    registerDestructor(self, () => destroyable.willDestroy()); // disable chains
 
     let m = meta(self);
     m.setInitializing(); // only return when in debug builds and `self` is the proxy created above
@@ -208,61 +155,61 @@ class CoreObject {
   /**
     An overridable method called when objects are instantiated. By default,
     does nothing unless it is overridden during class definition.
-     Example:
-     ```javascript
+       Example:
+       ```javascript
     import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
+       const Person = EmberObject.extend({
       init() {
         alert(`Name is ${this.get('name')}`);
       }
     });
-     let steve = Person.create({
+       let steve = Person.create({
       name: 'Steve'
     });
-     // alerts 'Name is Steve'.
+       // alerts 'Name is Steve'.
     ```
-     NOTE: If you do override `init` for a framework class like `Component`
+       NOTE: If you do override `init` for a framework class like `Component`
     from `@ember/component`, be sure to call `this._super(...arguments)`
     in your `init` declaration!
     If you don't, Ember may not have an opportunity to
     do important setup work, and you'll see strange behavior in your
     application.
-     @method init
+       @method init
     @public
   */
 
 
-  init() {}
+  init(_properties) {}
   /**
     Defines the properties that will be concatenated from the superclass
     (instead of overridden).
-     By default, when you extend an Ember class a property defined in
+       By default, when you extend an Ember class a property defined in
     the subclass overrides a property with the same name that is defined
     in the superclass. However, there are some cases where it is preferable
     to build up a property's value by combining the superclass' property
     value with the subclass' value. An example of this in use within Ember
     is the `classNames` property of `Component` from `@ember/component`.
-     Here is some sample code showing the difference between a concatenated
+       Here is some sample code showing the difference between a concatenated
     property and a normal one:
-     ```javascript
+       ```javascript
     import EmberObject from '@ember/object';
-     const Bar = EmberObject.extend({
+       const Bar = EmberObject.extend({
       // Configure which properties to concatenate
       concatenatedProperties: ['concatenatedProperty'],
-       someNonConcatenatedProperty: ['bar'],
+         someNonConcatenatedProperty: ['bar'],
       concatenatedProperty: ['bar']
     });
-     const FooBar = Bar.extend({
+       const FooBar = Bar.extend({
       someNonConcatenatedProperty: ['foo'],
       concatenatedProperty: ['foo']
     });
-     let fooBar = FooBar.create();
+       let fooBar = FooBar.create();
     fooBar.get('someNonConcatenatedProperty'); // ['foo']
     fooBar.get('concatenatedProperty'); // ['bar', 'foo']
     ```
-     This behavior extends to object creation as well. Continuing the
+       This behavior extends to object creation as well. Continuing the
     above example:
-     ```javascript
+       ```javascript
     let fooBar = FooBar.create({
       someNonConcatenatedProperty: ['baz'],
       concatenatedProperty: ['baz']
@@ -270,23 +217,23 @@ class CoreObject {
     fooBar.get('someNonConcatenatedProperty'); // ['baz']
     fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
     ```
-     Adding a single property that is not an array will just add it in the array:
-     ```javascript
+       Adding a single property that is not an array will just add it in the array:
+       ```javascript
     let fooBar = FooBar.create({
       concatenatedProperty: 'baz'
     })
     view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
     ```
-     Using the `concatenatedProperties` property, we can tell Ember to mix the
+       Using the `concatenatedProperties` property, we can tell Ember to mix the
     content of the properties.
-     In `Component` the `classNames`, `classNameBindings` and
+       In `Component` the `classNames`, `classNameBindings` and
     `attributeBindings` properties are concatenated.
-     This feature is available for you to use throughout the Ember object model,
+       This feature is available for you to use throughout the Ember object model,
     although typical app developers are likely to use it infrequently. Since
     it changes expectations about behavior of properties, you should properly
     document its usage in each individual concatenated property (to not
     mislead your users to think they can override the property in a subclass).
-     @property concatenatedProperties
+       @property concatenatedProperties
     @type Array
     @default null
     @public
@@ -295,20 +242,20 @@ class CoreObject {
   /**
     Defines the properties that will be merged from the superclass
     (instead of overridden).
-     By default, when you extend an Ember class a property defined in
+       By default, when you extend an Ember class a property defined in
     the subclass overrides a property with the same name that is defined
     in the superclass. However, there are some cases where it is preferable
     to build up a property's value by merging the superclass property value
     with the subclass property's value. An example of this in use within Ember
     is the `queryParams` property of routes.
-     Here is some sample code showing the difference between a merged
+       Here is some sample code showing the difference between a merged
     property and a normal one:
-     ```javascript
+       ```javascript
     import EmberObject from '@ember/object';
-     const Bar = EmberObject.extend({
+       const Bar = EmberObject.extend({
       // Configure which properties are to be merged
       mergedProperties: ['mergedProperty'],
-       someNonMergedProperty: {
+         someNonMergedProperty: {
         nonMerged: 'superclass value of nonMerged'
       },
       mergedProperty: {
@@ -316,7 +263,7 @@ class CoreObject {
         limit: { replace: true }
       }
     });
-     const FooBar = Bar.extend({
+       const FooBar = Bar.extend({
       someNonMergedProperty: {
         completelyNonMerged: 'subclass value of nonMerged'
       },
@@ -324,13 +271,13 @@ class CoreObject {
         limit: { replace: false }
       }
     });
-     let fooBar = FooBar.create();
-     fooBar.get('someNonMergedProperty');
+       let fooBar = FooBar.create();
+       fooBar.get('someNonMergedProperty');
     // => { completelyNonMerged: 'subclass value of nonMerged' }
     //
     // Note the entire object, including the nonMerged property of
     // the superclass object, has been replaced
-     fooBar.get('mergedProperty');
+       fooBar.get('mergedProperty');
     // => {
     //   page: {replace: false},
     //   limit: {replace: false}
@@ -340,15 +287,15 @@ class CoreObject {
     // `limit` property's value of `false` has been merged from
     // the subclass.
     ```
-     This behavior is not available during object `create` calls. It is only
+       This behavior is not available during object `create` calls. It is only
     available at `extend` time.
-     In `Route` the `queryParams` property is merged.
-     This feature is available for you to use throughout the Ember object model,
+       In `Route` the `queryParams` property is merged.
+       This feature is available for you to use throughout the Ember object model,
     although typical app developers are likely to use it infrequently. Since
     it changes expectations about behavior of properties, you should properly
     document its usage in each individual merged property (to not
     mislead your users to think they can override the property in a subclass).
-     @property mergedProperties
+       @property mergedProperties
     @type Array
     @default null
     @public
@@ -356,9 +303,9 @@ class CoreObject {
 
   /**
     Destroyed object property flag.
-     if this property is `true` the observers and bindings were already
+       if this property is `true` the observers and bindings were already
     removed by the effect of calling the `destroy()` method.
-     @property isDestroyed
+       @property isDestroyed
     @default false
     @public
   */
@@ -368,14 +315,14 @@ class CoreObject {
     return isDestroyed(this);
   }
 
-  set isDestroyed(value) {
+  set isDestroyed(_value) {
     assert(`You cannot set \`${this}.isDestroyed\` directly, please use \`.destroy()\`.`, false);
   }
   /**
     Destruction scheduled flag. The `destroy()` method has been called.
-     The object stays intact until the end of the run loop at which point
+       The object stays intact until the end of the run loop at which point
     the `isDestroyed` flag is set.
-     @property isDestroying
+       @property isDestroying
     @default false
     @public
   */
@@ -385,17 +332,17 @@ class CoreObject {
     return isDestroying(this);
   }
 
-  set isDestroying(value) {
+  set isDestroying(_value) {
     assert(`You cannot set \`${this}.isDestroying\` directly, please use \`.destroy()\`.`, false);
   }
   /**
     Destroys an object by setting the `isDestroyed` flag and removing its
     metadata, which effectively destroys observers and bindings.
-     If you try to set a property on a destroyed object, an exception will be
+       If you try to set a property on a destroyed object, an exception will be
     raised.
-     Note that destruction is scheduled for the end of the run loop and does not
+       Note that destruction is scheduled for the end of the run loop and does not
     happen immediately.  It will set an isDestroying flag immediately.
-     @method destroy
+       @method destroy
     @return {EmberObject} receiver
     @public
   */
@@ -415,7 +362,7 @@ class CoreObject {
   }
   /**
     Override to implement teardown.
-     @method willDestroy
+       @method willDestroy
     @public
   */
 
@@ -425,22 +372,22 @@ class CoreObject {
     Returns a string representation which attempts to provide more information
     than Javascript's `toString` typically does, in a generic way for all Ember
     objects.
-     ```javascript
+       ```javascript
     import EmberObject from '@ember/object';
-     const Person = EmberObject.extend();
+       const Person = EmberObject.extend();
     person = Person.create();
     person.toString(); //=> "<Person:ember1024>"
     ```
-     If the object's class is not defined on an Ember namespace, it will
+       If the object's class is not defined on an Ember namespace, it will
     indicate it is a subclass of the registered superclass:
-     ```javascript
+       ```javascript
     const Student = Person.extend();
     let student = Student.create();
     student.toString(); //=> "<(subclass of Person):ember1025>"
     ```
-     If the method `toStringExtension` is defined, its return value will be
+       If the method `toStringExtension` is defined, its return value will be
     included in the output.
-     ```javascript
+       ```javascript
     const Teacher = Person.extend({
       toStringExtension() {
         return this.get('fullName');
@@ -449,133 +396,25 @@ class CoreObject {
     teacher = Teacher.create();
     teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
     ```
-     @method toString
+       @method toString
     @return {String} string representation
     @public
   */
 
 
   toString() {
-    let hasToStringExtension = typeof this.toStringExtension === 'function';
-    let extension = hasToStringExtension ? `:${this.toStringExtension()}` : '';
+    let extension = hasToStringExtension(this) ? `:${this.toStringExtension()}` : '';
     return `<${getFactoryFor(this) || '(unknown)'}:${guidFor(this)}${extension}>`;
   }
-  /**
-    Creates a new subclass.
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      say(thing) {
-        alert(thing);
-       }
-    });
-    ```
-     This defines a new subclass of EmberObject: `Person`. It contains one method: `say()`.
-     You can also create a subclass from any existing class by calling its `extend()` method.
-    For example, you might want to create a subclass of Ember's built-in `Component` class:
-     ```javascript
-    import Component from '@ember/component';
-     const PersonComponent = Component.extend({
-      tagName: 'li',
-      classNameBindings: ['isAdministrator']
-    });
-    ```
-     When defining a subclass, you can override methods but still access the
-    implementation of your parent class by calling the special `_super()` method:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      say(thing) {
-        let name = this.get('name');
-        alert(`${name} says: ${thing}`);
-      }
-    });
-     const Soldier = Person.extend({
-      say(thing) {
-        this._super(`${thing}, sir!`);
-      },
-      march(numberOfHours) {
-        alert(`${this.get('name')} marches for ${numberOfHours} hours.`);
-      }
-    });
-     let yehuda = Soldier.create({
-      name: 'Yehuda Katz'
-    });
-     yehuda.say('Yes');  // alerts "Yehuda Katz says: Yes, sir!"
-    ```
-     The `create()` on line #17 creates an *instance* of the `Soldier` class.
-    The `extend()` on line #8 creates a *subclass* of `Person`. Any instance
-    of the `Person` class will *not* have the `march()` method.
-     You can also pass `Mixin` classes to add additional properties to the subclass.
-     ```javascript
-    import EmberObject from '@ember/object';
-    import Mixin from '@ember/object/mixin';
-     const Person = EmberObject.extend({
-      say(thing) {
-        alert(`${this.get('name')} says: ${thing}`);
-      }
-    });
-     const SingingMixin = Mixin.create({
-      sing(thing) {
-        alert(`${this.get('name')} sings: la la la ${thing}`);
-      }
-    });
-     const BroadwayStar = Person.extend(SingingMixin, {
-      dance() {
-        alert(`${this.get('name')} dances: tap tap tap tap `);
-      }
-    });
-    ```
-     The `BroadwayStar` class contains three methods: `say()`, `sing()`, and `dance()`.
-     @method extend
-    @static
-    @for @ember/object
-    @param {Mixin} [mixins]* One or more Mixin classes
-    @param {Object} [arguments]* Object containing values to use within the new class
-    @public
-  */
 
-
-  static extend() {
+  static extend(...mixins) {
     let Class = class extends this {};
-    reopen.apply(Class.PrototypeMixin, arguments);
+    reopen.apply(Class.PrototypeMixin, mixins);
     return Class;
   }
-  /**
-    Creates an instance of a class. Accepts either no arguments, or an object
-    containing values to initialize the newly instantiated object with.
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      helloWorld() {
-        alert(`Hi, my name is ${this.get('name')}`);
-      }
-    });
-     let tom = Person.create({
-      name: 'Tom Dale'
-    });
-     tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
-    ```
-     `create` will call the `init` function if defined during
-    `AnyObject.extend`
-     If no arguments are passed to `create`, it will not set values to the new
-    instance during initialization:
-     ```javascript
-    let noName = Person.create();
-    noName.helloWorld(); // alerts undefined
-    ```
-     NOTE: For performance reasons, you cannot declare methods or computed
-    properties during `create`. You should instead declare methods and computed
-    properties when using `extend`.
-     @method create
-    @for @ember/object
-    @static
-    @param [arguments]*
-    @public
-  */
-
 
-  static create(props, extra) {
+  static create(...args) {
+    let props = args[0];
     let instance;
 
     if (props !== undefined) {
@@ -585,10 +424,10 @@ class CoreObject {
       instance = new this();
     }
 
-    if (extra === undefined) {
+    if (args.length <= 1) {
       initialize(instance, props);
     } else {
-      initialize(instance, flattenProps.apply(this, arguments));
+      initialize(instance, flattenProps.apply(this, args));
     }
 
     return instance;
@@ -596,34 +435,34 @@ class CoreObject {
   /**
     Augments a constructor's prototype with additional
     properties and functions:
-     ```javascript
+       ```javascript
     import EmberObject from '@ember/object';
-     const MyObject = EmberObject.extend({
+       const MyObject = EmberObject.extend({
       name: 'an object'
     });
-     o = MyObject.create();
+       o = MyObject.create();
     o.get('name'); // 'an object'
-     MyObject.reopen({
+       MyObject.reopen({
       say(msg) {
         console.log(msg);
       }
     });
-     o2 = MyObject.create();
+       o2 = MyObject.create();
     o2.say('hello'); // logs "hello"
-     o.say('goodbye'); // logs "goodbye"
+       o.say('goodbye'); // logs "goodbye"
     ```
-     To add functions and properties to the constructor itself,
+       To add functions and properties to the constructor itself,
     see `reopenClass`
-     @method reopen
+       @method reopen
     @for @ember/object
     @static
     @public
   */
 
 
-  static reopen() {
+  static reopen(...args) {
     this.willReopen();
-    reopen.apply(this.PrototypeMixin, arguments);
+    reopen.apply(this.PrototypeMixin, args);
     return this;
   }
 
@@ -642,55 +481,55 @@ class CoreObject {
   }
   /**
     Augments a constructor's own properties and functions:
-     ```javascript
+       ```javascript
     import EmberObject from '@ember/object';
-     const MyObject = EmberObject.extend({
+       const MyObject = EmberObject.extend({
       name: 'an object'
     });
-     MyObject.reopenClass({
+       MyObject.reopenClass({
       canBuild: false
     });
-     MyObject.canBuild; // false
+       MyObject.canBuild; // false
     o = MyObject.create();
     ```
-     In other words, this creates static properties and functions for the class.
+       In other words, this creates static properties and functions for the class.
     These are only available on the class and not on any instance of that class.
-     ```javascript
+       ```javascript
     import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
+       const Person = EmberObject.extend({
       name: '',
       sayHello() {
         alert(`Hello. My name is ${this.get('name')}`);
       }
     });
-     Person.reopenClass({
+       Person.reopenClass({
       species: 'Homo sapiens',
-       createPerson(name) {
+         createPerson(name) {
         return Person.create({ name });
       }
     });
-     let tom = Person.create({
+       let tom = Person.create({
       name: 'Tom Dale'
     });
     let yehuda = Person.createPerson('Yehuda Katz');
-     tom.sayHello(); // "Hello. My name is Tom Dale"
+       tom.sayHello(); // "Hello. My name is Tom Dale"
     yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
     alert(Person.species); // "Homo sapiens"
     ```
-     Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
+       Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
     variables. They are only valid on `Person`.
-     To add functions and properties to instances of
+       To add functions and properties to instances of
     a constructor by extending the constructor's prototype
     see `reopen`
-     @method reopenClass
+       @method reopenClass
     @for @ember/object
     @static
     @public
   */
 
 
-  static reopenClass() {
-    applyMixin(this, arguments);
+  static reopenClass(...mixins) {
+    applyMixin(this, mixins);
     return this;
   }
 
@@ -718,21 +557,21 @@ class CoreObject {
     metadata about how they function or what values they operate on. For
     example, computed property functions may close over variables that are then
     no longer available for introspection.
-     You can pass a hash of these values to a computed property like this:
-     ```javascript
+       You can pass a hash of these values to a computed property like this:
+       ```javascript
     import { computed } from '@ember/object';
-     person: computed(function() {
+       person: computed(function() {
       let personId = this.get('personId');
       return Person.create({ id: personId });
     }).meta({ type: Person })
     ```
-     Once you've done this, you can retrieve the values saved to the computed
+       Once you've done this, you can retrieve the values saved to the computed
     property from your class like this:
-     ```javascript
+       ```javascript
     MyClass.metaForProperty('person');
     ```
-     This will return the original hash that was passed to `meta()`.
-     @static
+       This will return the original hash that was passed to `meta()`.
+       @static
     @method metaForProperty
     @param key {String} property name
     @private
@@ -749,7 +588,7 @@ class CoreObject {
   /**
     Iterate over each computed property for the class, passing its name
     and any associated metadata (see `metaForProperty`) to the callback.
-     @static
+       @static
     @method eachComputedProperty
     @param {Function} callback
     @param {Object} binding
@@ -817,38 +656,15 @@ CoreObject.isClass = true;
 CoreObject.isMethod = false;
 
 function flattenProps(...props) {
-  let {
-    concatenatedProperties,
-    mergedProperties
-  } = this;
-  let hasConcatenatedProps = concatenatedProperties !== undefined && concatenatedProperties.length > 0;
-  let hasMergedProps = mergedProperties !== undefined && mergedProperties.length > 0;
   let initProperties = {};
 
-  for (let i = 0; i < props.length; i++) {
-    let properties = props[i];
+  for (let properties of props) {
     assert('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof Mixin));
     let keyNames = Object.keys(properties);
 
     for (let j = 0, k = keyNames.length; j < k; j++) {
       let keyName = keyNames[j];
       let value = properties[keyName];
-
-      if (hasConcatenatedProps && concatenatedProperties.indexOf(keyName) > -1) {
-        let baseValue = initProperties[keyName];
-
-        if (baseValue) {
-          value = makeArray(baseValue).concat(value);
-        } else {
-          value = makeArray(value);
-        }
-      }
-
-      if (hasMergedProps && mergedProperties.indexOf(keyName) > -1) {
-        let baseValue = initProperties[keyName];
-        value = Object.assign({}, baseValue, value);
-      }
-
       initProperties[keyName] = value;
     }
   }
@@ -859,7 +675,7 @@ function flattenProps(...props) {
 if (DEBUG) {
   /**
     Provides lookup-time type validation for injected properties.
-     @private
+       @private
     @method _onLookup
   */
   CoreObject._onLookup = function injectedPropertyAssertion(debugContainerKey) {
@@ -877,7 +693,7 @@ if (DEBUG) {
   /**
     Returns a hash of property names and container names that injected
     properties will lookup on the container lazily.
-     @method _lazyInjections
+       @method _lazyInjections
     @return {Object} Hash of all lazy injected property keys to container names
     @private
   */