Support the TypeScript `satisfies` operator

[JasonWeinzierl]

The satisfies operator was added in TypeScript 4.9. Some rules need to handle TSSatisfiesExpression or else satisfies can cause false negatives.

For example, these do not cause errors:

// no-async-subscribe
of(42).subscribe((async () => {}) satisfies Function);

// no-floating-observables
of(42) satisfies Observable<number>;

// no-ignored-subscription
of(42).subscribe() satisfies Subscription;

// no-ignored-subscribe
of(42).subscribe({} satisfies Partial<Observer<number>>);

// no-ignored-takewhile-value
let flag = true;
const whilst = of(42).pipe(takeWhile((() => flag) satisfies Function));

// no-implicit-any-catch
throwError(() => new Error('Kaboom!')).pipe(
  catchError((error => {
    console.error(error);
    return of('Error occurred');
  }) satisfies (error: any) => ObservableInput<any>),
);

// no-misused-observables
[1, 2, 3].forEach((i => of(i)) satisfies (i: number) => Observable<number>);

// no-redundant-notify
const subject$ = new Subject<number>();
subject$.next(42);
subject$.error(new Error('Kaboom!'));
subject$.complete() satisfies void;

// no-sharereplay - this one does trigger, but with the wrong message (forbiddenWithoutConfig)
const shared$ = of(42).pipe(
  shareReplay({ refCount: true } satisfies ShareReplayConfig),
);
 
// no-unsafe-takeuntil
const notifier = new Subject<void>();
const b = of(42);
of(42)
    .pipe(
      takeUntil(notifier) satisfies OperatorFunction<number, number>,
      combineLatestWith(b),
    )
    .subscribe((value) => { console.log(value); });

I discovered this after stumbling upon francoismassart/eslint-plugin-tailwindcss#396

[JasonWeinzierl]

Banged my head on this for a little while; I'm not sure how other plugins are handling satisfies (if at all). I can write a utility to unwrap a satisfies chain like this:

export function unwrapSatisfiesExpression(node: es.Node): es.Node {
  let current: es.Node = node;

  while (isTSSatisfiesExpression(current)) {
    current = current.expression;
  }

  return current;
}

but it feels like this is going to be expensive, maintenance-wise. Nearly every rule would need to use this utility to unwrap every step; for example, if a subscribe observer's callbacks parameters need to be checked, we'd need to (1) unwrap the observer object, (2) unwrap the callback in the observer, then (3) unwrap the parameters.

I'm stopping for now but it seems like something could be done with TSSatisfiesExpression's typeAnnotation parameter; can we use that to assume some sort of information about the inner expression?