[BUGFIX release] Correct types for Ember Arrays

packages/@ember/-internals/glimmer/lib/utils/iterator.ts

@@ -5,6 +5,7 @@ import type { Option } from '@glimmer/interfaces';
 import type { IteratorDelegate } from '@glimmer/reference';
 import { consumeTag, isTracking, tagFor } from '@glimmer/validator';
 import { EachInWrapper } from '../helpers/each-in';
+import type { NativeArray } from '@ember/array';
 
 export default function toIterator(iterable: unknown): Option<IteratorDelegate> {
   if (iterable instanceof EachInWrapper) {
@@ -100,11 +101,11 @@ class ArrayIterator extends BoundedIterator {
 }
 
 class EmberArrayIterator extends BoundedIterator {
-  static from(iterable: EmberArray<unknown>) {
+  static from(iterable: EmberArray<unknown> | NativeArray<unknown>) {
     return iterable.length > 0 ? new this(iterable) : null;
   }
 
-  constructor(private array: EmberArray<unknown>) {
+  constructor(private array: EmberArray<unknown> | NativeArray<unknown>) {
     super(array.length);
   }
 

packages/@ember/-internals/utils/lib/ember-array.ts

@@ -1,4 +1,4 @@
-import type EmberArray from '@ember/array';
+import type { EmberArrayLike } from '@ember/array';
 import { _WeakSet } from '@glimmer/util';
 
 const EMBER_ARRAYS = new _WeakSet();
@@ -7,6 +7,6 @@ export function setEmberArray(obj: object) {
   EMBER_ARRAYS.add(obj);
 }
 
-export function isEmberArray(obj: unknown): obj is EmberArray<unknown> {
+export function isEmberArray(obj: unknown): obj is EmberArrayLike<unknown> {
   return EMBER_ARRAYS.has(obj as object);
 }

packages/@ember/-internals/utils/types.ts

@@ -1,7 +1,21 @@
 export type AnyFn = (...args: any[]) => any;
 
-export type MethodNamesOf<T> = {
-  [K in keyof T]: T[K] extends AnyFn ? K : never;
-}[keyof T];
+// The formatting here is designed to help make this type actually be
+// comprehensible to mortals, including the mortals who came up with it.
+// prettier-ignore
+export type MethodsOf<T> = {
+  // This `keyof` check is the thing which gives us *only* these keys, and no
+  // `foo: never` appears in the final type.
+  [K in keyof T as T[K] extends AnyFn ? K : never]:
+    // While this makes sure the resolved type only has `AnyFn` in it, so that
+    // the resulting type is known to be only function types.
+    T[K] extends AnyFn ? T[K] : never;
+};
+
+export type MethodNamesOf<T> = keyof MethodsOf<T>;
+
+export type MethodParams<T, M extends MethodNamesOf<T>> = Parameters<MethodsOf<T>[M]>;
+
+export type MethodReturns<T, M extends MethodNamesOf<T>> = ReturnType<MethodsOf<T>[M]>;
 
 export type OmitFirst<F> = F extends [any, ...infer R] ? R : [];