Kill reopenClass

Author: wagenet

packages/@ember/-internals/container/tests/container_test.js

@@ -432,11 +432,9 @@ moduleFor(
       let Apple = factory();
       let Orange = factory();
 
-      Apple.reopenClass({
-        _lazyInjections() {
-          return [{ specifier: 'orange:main' }, { specifier: 'banana:main' }];
-        },
-      });
+      Apple._lazyInjections = function () {
+        return [{ specifier: 'orange:main' }, { specifier: 'banana:main' }];
+      };
 
       registry.register('apple:main', Apple);
       registry.register('orange:main', Orange);
@@ -459,12 +457,10 @@ moduleFor(
       let Apple = factory();
       let Orange = factory();
 
-      Apple.reopenClass({
-        _lazyInjections: () => {
-          assert.ok(true, 'should call lazy injection method');
-          return [{ specifier: 'orange:main' }];
-        },
-      });
+      Apple._lazyInjections = () => {
+        assert.ok(true, 'should call lazy injection method');
+        return [{ specifier: 'orange:main' }];
+      };
 
       registry.register('apple:main', Apple);
       registry.register('orange:main', Orange);

packages/@ember/-internals/glimmer/lib/component.ts

@@ -1103,7 +1103,7 @@ class Component<S = unknown>
     @property positionalParams
     @since 1.13.0
     */
-  declare static positionalParams: string | string[];
+  static positionalParams: string | string[];
 
   /**
     Layout can be used to wrap content in a component.
@@ -1614,11 +1614,6 @@ class Component<S = unknown>
   }
 }
 
-// We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
-Component.reopenClass({
-  positionalParams: [],
-});
-
 setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
 
 export default Component;

packages/@ember/-internals/glimmer/lib/views/outlet.ts

@@ -37,10 +37,6 @@ export default class OutletView {
     };
   }
 
-  static reopenClass(injections: any): void {
-    Object.assign(this, injections);
-  }
-
   static create(options: {
     environment: BootEnvironment;
     application: InternalOwner;

packages/@ember/-internals/glimmer/tests/integration/components/attrs-lookup-test.js

@@ -143,6 +143,8 @@ moduleFor(
 
       let instance;
       let FooBarComponent = class extends Component {
+        static positionalParams = ['firstPositional'];
+
         init() {
           super.init(...arguments);
           instance = this;
@@ -166,10 +168,6 @@ moduleFor(
         }
       };
 
-      FooBarComponent.reopenClass({
-        positionalParams: ['firstPositional'],
-      });
-
       this.registerComponent('foo-bar', { ComponentClass: FooBarComponent });
 
       this.render(`{{foo-bar this.firstPositional first=this.first second=this.second}}`, {

packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js

@@ -62,14 +62,7 @@ moduleFor(
         return;
       }
 
-      let Thing = setComponentTemplate(
-        compile('hello'),
-        Component.extend().reopenClass({
-          toString() {
-            return 'Thing';
-          },
-        })
-      );
+      let Thing = setComponentTemplate(compile('hello'), Component.extend());
 
       assert.throws(() => {
         setComponentTemplate(compile('foo'), Thing);

packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js

@@ -3253,9 +3253,9 @@ moduleFor(
 
       expectAssertion(() => {
         this.registerComponent('foo-bar', {
-          ComponentClass: MyComponent.reopenClass({
-            positionalParams: ['myVar'],
-          }),
+          ComponentClass: class extends MyComponent {
+            static positionalParams = ['myVar'];
+          },
           template:
             'MyVar1: {{attrs.myVar}} {{this.myVar}} MyVar2: {{this.myVar2}} {{attrs.myVar2}}',
         });
@@ -3268,9 +3268,9 @@ moduleFor(
 
       expectDeprecation(() => {
         this.registerComponent('foo-bar', {
-          ComponentClass: MyComponent.reopenClass({
-            positionalParams: ['myVar'],
-          }),
+          ComponentClass: class extends MyComponent {
+            static positionalParams = ['myVar'];
+          },
           template:
             'MyVar1: {{this.attrs.myVar}} {{this.myVar}} MyVar2: {{this.myVar2}} {{this.attrs.myVar2}}',
         });
@@ -3285,9 +3285,9 @@ moduleFor(
       let MyComponent = class extends Component {};
 
       this.registerComponent('foo-bar', {
-        ComponentClass: MyComponent.reopenClass({
-          positionalParams: ['myVar'],
-        }),
+        ComponentClass: class extends MyComponent {
+          static positionalParams = ['myVar'];
+        },
         template: 'MyVar1: {{@myVar}} {{this.myVar}} MyVar2: {{this.myVar2}} {{@myVar2}}',
       });
 

packages/@ember/engine/index.ts

@@ -551,10 +551,7 @@ export function buildInitializerMethod<
     // SAFETY: The superclass may be an Engine, we don't call unless we confirmed it was ok.
     let superclass = this.superclass as typeof Engine;
     if (superclass[bucketName] !== undefined && superclass[bucketName] === this[bucketName]) {
-      let attrs = {
-        [bucketName]: Object.create(this[bucketName]),
-      };
-      this.reopenClass(attrs);
+      this[bucketName] = Object.create(this[bucketName]);
     }
 
     assert(

packages/@ember/object/core.ts

@@ -17,8 +17,7 @@ import {
   DEBUG_INJECTION_FUNCTIONS,
   hasUnknownProperty,
 } from '@ember/-internals/metal';
-import Mixin, { applyMixin } from '@ember/object/mixin';
-import { ActionHandler } from '@ember/-internals/runtime';
+import Mixin from '@ember/object/mixin';
 import makeArray from '@ember/array/make';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
@@ -801,71 +800,6 @@ class CoreObject {
     return instance as InstanceType<C> & MergeArray<Args>;
   }
 
-  /**
-    Augments a constructor's own properties and functions:
-
-    ```javascript
-    import EmberObject from '@ember/object';
-
-    const MyObject = EmberObject.extend({
-      name: 'an object'
-    });
-
-    MyObject.reopenClass({
-      canBuild: false
-    });
-
-    MyObject.canBuild; // false
-    o = MyObject.create();
-    ```
-
-    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
-    import EmberObject from '@ember/object';
-
-    const Person = EmberObject.extend({
-      name: '',
-      sayHello() {
-        alert(`Hello. My name is ${this.get('name')}`);
-      }
-    });
-
-    Person.reopenClass({
-      species: 'Homo sapiens',
-
-      createPerson(name) {
-        return Person.create({ name });
-      }
-    });
-
-    let tom = Person.create({
-      name: 'Tom Dale'
-    });
-    let yehuda = Person.createPerson('Yehuda Katz');
-
-    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`
-    variables. They are only valid on `Person`.
-
-    @method reopenClass
-    @for @ember/object
-    @static
-    @public
-  */
-  static reopenClass<C extends typeof CoreObject>(
-    this: C,
-    ...mixins: Array<Mixin | Record<string, unknown>>
-  ): C {
-    applyMixin(this, mixins);
-    return this;
-  }
-
   static detect(obj: unknown) {
     if ('function' !== typeof obj) {
       return false;

packages/@ember/object/mixin.ts

@@ -393,7 +393,7 @@ function updateObserversAndListeners(obj: object, key: string, fn: Function, add
   }
 }
 
-export function applyMixin(
+function applyMixin(
   obj: Record<string, any>,
   mixins: Array<Mixin | Record<string, unknown>>,
   _hideKeys = false

packages/@ember/object/tests/extend_test.js

@@ -1,4 +1,4 @@
-import { computed, get } from '@ember/object';
+import { computed } from '@ember/object';
 import EmberObject, { observer } from '@ember/object';
 import { moduleFor, AbstractTestCase, runLoopSettled } from 'internal-test-helpers';
 
@@ -92,36 +92,6 @@ moduleFor(
       );
     }
 
-    ['@test With concatenatedProperties class properties'](assert) {
-      let SomeClass = EmberObject.extend();
-      SomeClass.reopenClass({
-        concatenatedProperties: ['things'],
-        things: 'foo',
-      });
-      let AnotherClass = SomeClass.extend();
-      AnotherClass.reopenClass({ things: 'bar' });
-      let YetAnotherClass = SomeClass.extend();
-      YetAnotherClass.reopenClass({ things: 'baz' });
-      let some = SomeClass.create();
-      let another = AnotherClass.create();
-      let yetAnother = YetAnotherClass.create();
-      assert.deepEqual(
-        get(some.constructor, 'things'),
-        ['foo'],
-        'base class should have just its value'
-      );
-      assert.deepEqual(
-        get(another.constructor, 'things'),
-        ['foo', 'bar'],
-        "subclass should have base class' and its own"
-      );
-      assert.deepEqual(
-        get(yetAnother.constructor, 'things'),
-        ['foo', 'baz'],
-        "subclass should have base class' and its own"
-      );
-    }
-
     async ['@test Overriding a computed property with an observer'](assert) {
       let Parent = EmberObject.extend({
         foo: computed(function () {