Move Meta mixin methods to standalone fns in @ember/object/mixin

The `addMixin` / `hasMixin` / `forEachMixins` methods only existed on
`Meta` to be called by `@ember/object/mixin`. Keeping them on the class
forced a static reference from `Meta` (reachable from the renderer
through the property accessor / tag chain) into the classic `Mixin`
graph.

Move them out as standalone functions (`metaAddMixin` / `metaHasMixin` /
`metaForEachMixins`) in `mixin.ts` itself, poking at `Meta`'s public
`_mixins` and `parent` fields directly. With this split, bundles that
don't import `@ember/object/mixin` get a cleaner `Meta` class — in the
hello-world prod bundle the `addMixin` / `hasMixin` / `forEachMixins`
identifiers go from present to fully absent, and `Mixin` references
drop from 12 to 5.

The methods were `@internal` and only called from `mixin.ts`, so this
is a purely internal refactor.

Verified: lint clean, type-checks pass, hello-world builds at
134.19 KB / 42.94 KB gzip (unchanged), classic v2-app-template tests
1/1 pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: NullVoxPopuli

packages/@ember/-internals/meta/lib/meta.ts

@@ -267,44 +267,14 @@ export class Meta {
     return undefined;
   }
 
-  /** @internal */
-  addMixin(mixin: any) {
-    assert(
-      isDestroyed(this.source)
-        ? `Cannot add mixins of \`${toString(mixin)}\` on \`${toString(
-            this.source
-          )}\` call addMixin after it has been destroyed.`
-        : '',
-      !isDestroyed(this.source)
-    );
-    let set = this._getOrCreateOwnSet('_mixins');
-    set.add(mixin);
-  }
-
-  /** @internal */
-  hasMixin(mixin: any) {
-    return this._hasInInheritedSet('_mixins', mixin);
-  }
-
-  /** @internal */
-  forEachMixins(fn: Function) {
-    let pointer: Meta | null = this;
-    let seen: Set<any> | undefined;
-    while (pointer !== null) {
-      let set = pointer._mixins;
-      if (set !== undefined) {
-        seen = seen === undefined ? new Set() : seen;
-        // TODO cleanup typing here
-        set.forEach((mixin: any) => {
-          if (!seen!.has(mixin)) {
-            seen!.add(mixin);
-            fn(mixin);
-          }
-        });
-      }
-      pointer = pointer.parent;
-    }
-  }
+  // The mixin-tracking helpers (`addMixin` / `hasMixin` / `forEachMixins`)
+  // moved to `@ember/object/mixin` as standalone functions
+  // (`metaAddMixin` / `metaHasMixin` / `metaForEachMixins`). They poke
+  // directly at the public `_mixins` / `parent` fields here. Splitting
+  // them out keeps the `Meta` class — which is reachable from the
+  // renderer via the property accessor + tag chain — free of references
+  // to the classic `Mixin` machinery, so bundles that don't actually use
+  // mixins can tree-shake `@ember/object/mixin` away.
 
   /** @internal */
   writeDescriptors(subkey: string, value: any) {

packages/@ember/object/mixin.ts

@@ -4,6 +4,61 @@
 import { INIT_FACTORY } from '@ember/-internals/container/lib/container';
 import type { Meta } from '@ember/-internals/meta/lib/meta';
 import { meta as metaFor, peekMeta } from '@ember/-internals/meta/lib/meta';
+import { isDestroyed } from '@glimmer/destroyable';
+import toString from '@ember/-internals/utils/lib/to-string';
+
+// Mixin-tracking helpers — moved out of `Meta` so the renderer-only
+// path (which reaches `Meta` through the tag/property graph) doesn't
+// pull a reference to `Mixin` into the bundle. They poke at `Meta`'s
+// public `_mixins` / `parent` fields directly.
+
+ 
+function metaAddMixin(meta: Meta, mixin: any): void {
+  assert(
+    isDestroyed(meta.source as object)
+      ? `Cannot add mixins of \`${toString(mixin)}\` on \`${toString(
+          meta.source
+        )}\` call addMixin after it has been destroyed.`
+      : '',
+    !isDestroyed(meta.source as object)
+  );
+  let set = meta._mixins ?? (meta._mixins = new Set());
+  set.add(mixin);
+}
+
+ 
+function metaHasMixin(meta: Meta, mixin: any): boolean {
+  let pointer: Meta | null = meta;
+  while (pointer !== null) {
+    let set = pointer._mixins;
+    if (set !== undefined && set.has(mixin)) {
+      return true;
+    }
+    pointer = pointer.parent;
+  }
+  return false;
+}
+
+ 
+function metaForEachMixins(meta: Meta, fn: (mixin: any) => void): void {
+  let pointer: Meta | null = meta;
+   
+  let seen: Set<any> | undefined;
+  while (pointer !== null) {
+    let set = pointer._mixins;
+    if (set !== undefined) {
+      seen = seen === undefined ? new Set() : seen;
+       
+      set.forEach((mixin: any) => {
+        if (!seen!.has(mixin)) {
+          seen!.add(mixin);
+          fn(mixin);
+        }
+      });
+    }
+    pointer = pointer.parent;
+  }
+}
 import { observerListenerMetaFor, ROOT, wrap } from '@ember/-internals/utils/lib/super';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
@@ -247,10 +302,10 @@ function mergeMixins(
     );
 
     if (MIXINS.has(currentMixin)) {
-      if (meta.hasMixin(currentMixin)) {
+      if (metaHasMixin(meta, currentMixin)) {
         continue;
       }
-      meta.addMixin(currentMixin);
+      metaAddMixin(meta, currentMixin);
 
       let { properties, mixins } = currentMixin;
 
@@ -592,7 +647,7 @@ export default class Mixin {
       return ret;
     }
 
-    meta.forEachMixins((currentMixin: Mixin) => {
+    metaForEachMixins(meta, (currentMixin: Mixin) => {
       // skip primitive mixins since these are always anonymous
       if (!currentMixin.properties) {
         ret.push(currentMixin);
@@ -664,7 +719,7 @@ export default class Mixin {
     if (meta === null) {
       return false;
     }
-    return meta.hasMixin(this);
+    return metaHasMixin(meta, this);
   }
 
   /** @internal */