WIP: Implement type-checking for signal inputs

New implementation of type-checking for signal inputs. Much simpler, and
without causing signficant type check block changes that would require
more changes to the language service completion logic / or rewrites of
more than 50+ handwritten code output tests for type check blocks.

See previous commits for other explored solutions.

Author: devversion

packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.ts

@@ -754,6 +754,8 @@ class TcbDirectiveInputsOp extends TcbOp {
             dirId = this.scope.resolve(this.node, this.dir);
           }
 
+          // TODO(signals): signal input with a restricted modifier
+
           const id = this.tcb.allocateId();
           const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);
           if (!ts.isTypeReferenceNode(dirTypeRef)) {
@@ -771,14 +773,42 @@ class TcbDirectiveInputsOp extends TcbOp {
             dirId = this.scope.resolve(this.node, this.dir);
           }
 
-          // To get errors assign directly to the fields on the instance, using property access
-          // when possible. String literal fields may not be valid JS identifiers so we use
-          // literal element access instead for those cases.
-          target = this.dir.stringLiteralInputFields.has(fieldName) ?
-              ts.factory.createElementAccessExpression(
-                  dirId, ts.factory.createStringLiteral(fieldName)) :
-              ts.factory.createPropertyAccessExpression(
-                  dirId, ts.factory.createIdentifier(fieldName));
+          if (this.dir.isSignal) {
+            const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);
+            if (!ts.isTypeReferenceNode(dirTypeRef)) {
+              throw new Error(
+                  `Expected TypeReferenceNode from reference to ${this.dir.ref.debugName}`);
+            }
+
+            const getSignalWriteType = this.tcb.env.referenceExternalType(
+                R3Identifiers.getInputSignalWriteType.moduleName,
+                R3Identifiers.getInputSignalWriteType.name);
+            if (!ts.isTypeReferenceNode(getSignalWriteType)) {
+              throw new Error(`Expected TypeReferenceNode from reference to ${
+                  R3Identifiers.getInputSignalWriteType.name}`);
+            }
+
+            const inputFieldType = ts.factory.createIndexedAccessTypeNode(
+                ts.factory.createTypeQueryNode(dirId as ts.Identifier),
+                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(fieldName)));
+
+            const inputWriteTypeId = this.tcb.allocateId();
+            const inputWriteTypeSt = tsDeclareVariable(
+                inputWriteTypeId,
+                ts.factory.createTypeReferenceNode(getSignalWriteType.typeName, [inputFieldType]));
+            this.scope.addStatement(inputWriteTypeSt);
+
+            target = inputWriteTypeId;
+          } else {
+            // To get errors assign directly to the fields on the instance, using property access
+            // when possible. String literal fields may not be valid JS identifiers so we use
+            // literal element access instead for those cases.
+            target = this.dir.stringLiteralInputFields.has(fieldName) ?
+                ts.factory.createElementAccessExpression(
+                    dirId, ts.factory.createStringLiteral(fieldName)) :
+                ts.factory.createPropertyAccessExpression(
+                    dirId, ts.factory.createIdentifier(fieldName));
+          }
         }
 
         if (attr.attribute.keySpan !== undefined) {

packages/compiler/src/render3/r3_identifiers.ts

@@ -391,4 +391,8 @@ export class Identifiers {
       o.ExternalReference = {name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE};
   static validateIframeAttribute:
       o.ExternalReference = {name: 'ɵɵvalidateIframeAttribute', moduleName: CORE};
+
+
+  // type-checking
+  static getInputSignalWriteType = {name: 'ɵɵGetInputSignalWriteType', moduleName: CORE};
 }

packages/core/src/core_reactivity_export_internal.ts

@@ -20,7 +20,6 @@ export {
   CreateSignalOptions,
   signal,
   WritableSignal,
-  ɵɵtoWritableSignal
 } from './render3/reactivity/signal';
 export {
   untracked,
@@ -38,6 +37,6 @@ export {
   assertNotInReactiveContext,
 } from './render3/reactivity/asserts';
 export {input} from './render3/reactivity/input';
-export {InputSignal} from './render3/reactivity/input_signal';
+export {InputSignal, ɵɵGetInputSignalWriteType} from './render3/reactivity/input_signal';
 export {ModelSignal} from './render3/reactivity/model_signal';
 // clang-format on

packages/core/src/render3/reactivity/input_signal.ts

@@ -24,6 +24,9 @@ export type InputSignal<ReadT, WriteT> = Signal<ReadT>&{
   [BRAND_WRITE_TYPE]: WriteT;
 };
 
+// TODO(signals)
+export type ɵɵGetInputSignalWriteType<T> = T extends InputSignal<any, infer X>? X : never;
+
 export interface InputSignalNode<ReadT, WriteT> extends ComputedNode<ReadT> {
   /**
    * Whether the input signal is initialized. If not, accessing the node results in an error.

packages/core/test/render3/jit_environment_spec.ts

@@ -21,6 +21,9 @@ const INTERFACE_EXCEPTIONS = new Set<string>([
   'ɵɵPipeDeclaration',
   'ɵɵFactoryDeclaration',
   'ModuleWithProviders',
+
+  // Type-only needed for type checking.
+  'ɵɵGetInputSignalWriteType',
 ]);
 
 /**