test(core): type tests for linkedSignal (angular#60857)

This commit adds type inference tests for `linkedSignal` usages, to capture their behavior w.r.t.
type inference. Note that there's some situations where type inference doesn't work as you might
expect/hope; these have been included to capture their behavior but may be revisited in the future
if the inference capabilities are expanded for this scenario.

Closes angular#60423

PR Close angular#60857

Author: JoostK

packages/core/test/authoring/BUILD.bazel

@@ -4,6 +4,7 @@ ts_library(
     name = "signal_authoring_signature_test_lib",
     testonly = True,
     srcs = [
+        "linked_signal_signature_test.ts",
         "signal_input_signature_test.ts",
         "signal_model_signature_test.ts",
         "signal_queries_signature_test.ts",

packages/core/test/authoring/linked_signal_signature_test.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+/**
+ * @fileoverview
+ * This file contains various signal `input()` patterns and ensures
+ * the resulting types match our expectations (via comments asserting the `.d.ts`).
+ */
+
+import {signal, linkedSignal} from '@angular/core';
+// import preserved to simplify `.d.ts` emit and simplify the `type_tester` logic.
+// tslint:disable-next-line no-duplicate-imports
+import {WritableSignal} from '@angular/core';
+
+const source = signal(0);
+
+declare function stringEqual(a: string, b: string): boolean;
+declare function numberEqual(a: number, b: number): boolean;
+
+export class LinkedSignalSignatureTest {
+  /** number */
+  simple = linkedSignal(() => 0);
+
+  /** number */
+  simpleWithCompatibleEqual = linkedSignal(source, {
+    equal: numberEqual,
+  });
+
+  /** number */
+  simpleWithIncompatibleEqual = linkedSignal(source, {
+    // @ts-expect-error assignability error
+    equal: stringEqual,
+  });
+
+  /** number */
+  advanced = linkedSignal({source, computation: (s) => s * 2});
+
+  /** string */
+  advancedWithCompatibleEqual = linkedSignal({
+    source,
+    computation: (s) => String(s),
+    equal: (a, b) => true,
+  });
+
+  /** unknown */
+  /**
+   * An incompatible `equal` function results in an overload resolution failure, causing the type `unknown` to be
+   * inferred. This test aims to capture this limitation and may be revisited if this were to become supported.
+   */
+  advancedWithIncompatibleEqual =
+    // @ts-expect-error overload resolution error
+    linkedSignal({
+      source,
+      // @ts-expect-error implicit any error
+      computation: (s) => String(s),
+      equal: numberEqual,
+    });
+
+  /** unknown */
+  /**
+   * Due to the cyclic nature of `previous`'s type and the computation's return type, TypeScript isn't able to infer
+   * generic type arguments. This test aims to capture this limitation and may be revisited if this were to become
+   * supported.
+   *
+   * @see https://github.com/microsoft/TypeScript/issues/49618
+   * @see https://github.com/angular/angular/issues/60423
+   */
+  advancedWithPreviousImplicitGenerics = linkedSignal({
+    source,
+    computation: (s, previous) => String(s),
+  });
+
+  /** string */
+  advancedWithPreviousExplicitGenerics = linkedSignal<number, string>({
+    source,
+    computation: (s, previous) => String(s),
+  });
+}

packages/core/test/authoring/type_tester.ts

@@ -13,6 +13,7 @@ import url from 'url';
 
 /** Currently-configured tests. */
 const TESTS = new Map<string, (value: string) => string>([
+  ['linked_signal_signature_test', (v) => `WritableSignal<${v}>`],
   [
     'signal_input_signature_test',
     (v) => (v.includes(',') ? `InputSignalWithTransform<${v}>` : `InputSignal<${v}>`),