refactor(compiler-cli): decouple TemplateSymbolBuilder from ts.TypeChecker

This updates the SymbolBuilder to no longer use ts.TypeChecker internally to
build symbols for the language service. These lookups are deferred/done later
using the newly expanded template type checker API.

Author: atscott

packages/compiler-cli/src/ngtsc/typecheck/api/checker.ts

@@ -45,6 +45,8 @@ import {
   TsCompletionEntryInfo,
 } from './scope';
 import {
+  BindingSymbol,
+  ClassSymbol,
   ElementSymbol,
   SelectorlessComponentSymbol,
   SelectorlessDirectiveSymbol,
@@ -178,6 +180,17 @@ export interface TemplateTypeChecker {
   ): SelectorlessDirectiveSymbol | null;
   getSymbolOfNode(node: AST | TmplAstNode, component: ts.ClassDeclaration): Symbol | null;
 
+  /**
+   * Translates a symbol's TCB location to its corresponding ts.Type using the program's type checker.
+   * This is used by compiler checks that need semantic type information from a positional symbol.
+   */
+  getTypeOfSymbol(symbol: Symbol | BindingSymbol | ClassSymbol): ts.Type | null;
+
+  /**
+   * Translates a symbol's TCB location to its corresponding ts.Symbol using the program's type checker.
+   */
+  getTsSymbolOfSymbol(symbol: Symbol | BindingSymbol | ClassSymbol): ts.Symbol | null;
+
   /**
    * Get "global" `Completion`s in the given context.
    *

packages/compiler-cli/src/ngtsc/typecheck/api/scope.ts

@@ -61,11 +61,6 @@ export interface TsCompletionEntryInfo {
 export interface PotentialDirective {
   ref: Reference<ClassDeclaration>;
 
-  /**
-   * The `ts.Symbol` for the directive class.
-   */
-  tsSymbol: SymbolWithValueDeclaration;
-
   /**
    * The module which declares the directive.
    */
@@ -106,11 +101,6 @@ export interface PotentialDirective {
 export interface PotentialPipe {
   ref: Reference<ClassDeclaration>;
 
-  /**
-   * The `ts.Symbol` for the pipe class.
-   */
-  tsSymbol: ts.Symbol;
-
   /**
    * Name of the pipe.
    */

packages/compiler-cli/src/ngtsc/typecheck/api/symbols.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  MatchSource,
   TmplAstComponent,
   TmplAstDirective,
   TmplAstElement,
@@ -80,20 +81,20 @@ export interface TcbLocation {
 
   /** The location in the file where node appears. */
   positionInFile: number;
+
+  /** The end position in the TCB file. Used to correctly resolve AST expressions. */
+  endInFile?: number;
 }
 
 /**
  * A generic representation of some node in a template.
  */
 export interface TsNodeSymbolInfo {
-  /** The `ts.Type` of the template node. */
-  tsType: ts.Type;
-
-  /** The `ts.Symbol` for the template node */
-  tsSymbol: ts.Symbol | null;
-
   /** The position of the most relevant part of the template node. */
   tcbLocation: TcbLocation;
+
+  /** The position of the expression used to determine the type. */
+  tcbTypeLocation?: TcbLocation;
 }
 
 /**
@@ -102,29 +103,17 @@ export interface TsNodeSymbolInfo {
 export interface ExpressionSymbol {
   kind: SymbolKind.Expression;
 
-  /** The `ts.Type` of the expression AST. */
-  tsType: ts.Type;
-
-  /**
-   * The `ts.Symbol` of the entity. This could be `null`, for example `AST` expression
-   * `{{foo.bar + foo.baz}}` does not have a `ts.Symbol` but `foo.bar` and `foo.baz` both do.
-   */
-  tsSymbol: ts.Symbol | null;
-
   /** The position of the most relevant part of the expression. */
   tcbLocation: TcbLocation;
+
+  /** The position of the expression used to determine the type. */
+  tcbTypeLocation?: TcbLocation;
 }
 
 /** Represents either an input or output binding in a template. */
 export interface BindingSymbol {
   kind: SymbolKind.Binding;
 
-  /** The `ts.Type` of the class member on the directive that is the target of the binding. */
-  tsType: ts.Type;
-
-  /** The `ts.Symbol` of the class member on the directive that is the target of the binding. */
-  tsSymbol: ts.Symbol;
-
   /**
    * The `DirectiveSymbol` or `ElementSymbol` for the Directive, Component, or `HTMLElement` with
    * the binding.
@@ -133,6 +122,9 @@ export interface BindingSymbol {
 
   /** The location in the shim file where the field access for the binding appears. */
   tcbLocation: TcbLocation;
+
+  /** The position of the expression used to determine the type. */
+  tcbTypeLocation?: TcbLocation;
 }
 
 /**
@@ -161,24 +153,6 @@ export interface OutputBindingSymbol {
 export interface ReferenceSymbol {
   kind: SymbolKind.Reference;
 
-  /**
-   * The `ts.Type` of the Reference value.
-   *
-   * `TmplAstTemplate` - The type of the `TemplateRef`
-   * `TmplAstElement` - The `ts.Type` for the `HTMLElement`.
-   * Directive - The `ts.Type` for the class declaration.
-   */
-  tsType: ts.Type;
-
-  /**
-   * The `ts.Symbol` for the Reference value.
-   *
-   * `TmplAstTemplate` - A `TemplateRef` symbol.
-   * `TmplAstElement` - The symbol for the `HTMLElement`.
-   * Directive - The symbol for the class declaration of the directive.
-   */
-  tsSymbol: ts.Symbol;
-
   /**
    * Depending on the type of the reference, this is one of the following:
    *  - `TmplAstElement` when the local ref refers to the HTML element
@@ -219,20 +193,6 @@ export interface ReferenceSymbol {
 export interface VariableSymbol {
   kind: SymbolKind.Variable;
 
-  /**
-   * The `ts.Type` of the entity.
-   *
-   * This will be `any` if there is no `ngTemplateContextGuard`.
-   */
-  tsType: ts.Type;
-
-  /**
-   * The `ts.Symbol` for the context variable.
-   *
-   * This will be `null` if there is no `ngTemplateContextGuard`.
-   */
-  tsSymbol: ts.Symbol | null;
-
   /**
    * The node in the `TemplateAst` where the variable is declared. That is, the node for the `let-`
    * node in the template.
@@ -244,10 +204,7 @@ export interface VariableSymbol {
    */
   localVarLocation: TcbLocation;
 
-  /**
-   * The location in the shim file for the initializer node of the variable that represents the
-   * template variable.
-   */
+  /** The location in the shim file for the initializer node of the variable that represents the template variable. */
   initializerLocation: TcbLocation;
 }
 
@@ -257,23 +214,16 @@ export interface VariableSymbol {
 export interface LetDeclarationSymbol {
   kind: SymbolKind.LetDeclaration;
 
-  /** The `ts.Type` of the entity. */
-  tsType: ts.Type;
-
-  /**
-   * The `ts.Symbol` for the declaration.
-   *
-   * This will be `null` if the symbol could not be resolved using the type checker.
-   */
-  tsSymbol: ts.Symbol | null;
-
   /** The node in the `TemplateAst` where the `@let` is declared.  */
   declaration: TmplAstLetDeclaration;
 
   /**
    * The location in the shim file for the identifier of the `@let` declaration.
    */
   localVarLocation: TcbLocation;
+
+  /** The location in the shim file of the `@let` declaration's initializer expression. */
+  initializerLocation: TcbLocation;
 }
 
 /**
@@ -282,12 +232,6 @@ export interface LetDeclarationSymbol {
 export interface ElementSymbol {
   kind: SymbolKind.Element;
 
-  /** The `ts.Type` for the `HTMLElement`. */
-  tsType: ts.Type;
-
-  /** The `ts.Symbol` for the `HTMLElement`. */
-  tsSymbol: ts.Symbol | null;
-
   /** A list of directives applied to the element. */
   directives: DirectiveSymbol[];
 
@@ -310,12 +254,6 @@ export interface TemplateSymbol {
 export interface SelectorlessComponentSymbol {
   kind: SymbolKind.SelectorlessComponent;
 
-  /** The `ts.Type` for the component class. */
-  tsType: ts.Type;
-
-  /** The `ts.Symbol` for the component class. */
-  tsSymbol: ts.Symbol | null;
-
   /**
    * Includes the component class itself and any host directives
    * that may have been applied as a side-effect of it.
@@ -333,12 +271,6 @@ export interface SelectorlessComponentSymbol {
 export interface SelectorlessDirectiveSymbol {
   kind: SymbolKind.SelectorlessDirective;
 
-  /** The `ts.Type` for the directive class. */
-  tsType: ts.Type;
-
-  /** The `ts.Symbol` for the directive class. */
-  tsSymbol: ts.Symbol | null;
-
   /**
    * Includes the directive class itself and any host directives
    * that may have been applied as a side-effect of it.
@@ -356,9 +288,6 @@ export interface SelectorlessDirectiveSymbol {
 interface DirectiveSymbolBase extends PotentialDirective {
   kind: SymbolKind.Directive;
 
-  /** The `ts.Type` for the class declaration. */
-  tsType: ts.Type;
-
   /** The location in the shim file for the variable that holds the type of the directive. */
   tcbLocation: TcbLocation;
 }
@@ -368,9 +297,9 @@ interface DirectiveSymbolBase extends PotentialDirective {
  * template.
  */
 export type DirectiveSymbol =
-  | (DirectiveSymbolBase & {isHostDirective: false})
+  | (DirectiveSymbolBase & {matchSource: MatchSource.Selector})
   | (DirectiveSymbolBase & {
-      isHostDirective: true;
+      matchSource: MatchSource.HostDirective;
       exposedInputs: Record<string, string> | null;
       exposedOutputs: Record<string, string> | null;
     });
@@ -393,15 +322,6 @@ export interface DomBindingSymbol {
 export interface PipeSymbol {
   kind: SymbolKind.Pipe;
 
-  /** The `ts.Type` of the transform node. */
-  tsType: ts.Type;
-
-  /**
-   * The `ts.Symbol` for the transform call. This could be `null` when `checkTypeOfPipes` is set to
-   * `false` because the transform call would be of the form `(_pipe1 as any).transform()`
-   */
-  tsSymbol: ts.Symbol | null;
-
   /** The position of the transform call in the template. */
   tcbLocation: TcbLocation;
 
@@ -411,12 +331,6 @@ export interface PipeSymbol {
 
 /** Represents an instance of a class found in the TCB, i.e. `var _pipe1: MyPipe = null!; */
 export interface ClassSymbol {
-  /** The `ts.Type` of class. */
-  tsType: ts.Type;
-
-  /** The `ts.Symbol` for class. */
-  tsSymbol: SymbolWithValueDeclaration;
-
   /** The position for the variable declaration for the class instance. */
   tcbLocation: TcbLocation;
 }

packages/compiler-cli/src/ngtsc/typecheck/extended/checks/interpolated_signal_not_invoked/index.ts

@@ -168,9 +168,12 @@ function buildDiagnosticForSignal(
   node: PropertyRead,
   component: ts.ClassDeclaration,
 ): Array<NgTemplateDiagnostic<ErrorCode.INTERPOLATED_SIGNAL_NOT_INVOKED>> {
-  // check for `{{ mySignal }}`
   const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
-  if (symbol !== null && symbol.kind === SymbolKind.Expression && isSignalReference(symbol)) {
+  if (
+    symbol !== null &&
+    symbol.kind === SymbolKind.Expression &&
+    isSignalReference(symbol, ctx.templateTypeChecker)
+  ) {
     const templateMapping = ctx.templateTypeChecker.getSourceMappingAtTcbLocation(
       symbol.tcbLocation,
     )!;
@@ -192,11 +195,19 @@ function buildDiagnosticForSignal(
   if (!isFunctionInstanceProperty(node.name) && !isSignalInstanceProperty(node.name)) {
     return [];
   }
+
+  // If the receiver is not a PropertyRead, it means it's not a simple property access
+  // (e.g., it could be a MethodCall like `mySignal().set`). In that case, we assume
+  // it was invoked and skip the warning.
+  if (!(node.receiver instanceof PropertyRead)) {
+    return [];
+  }
+
   const symbolOfReceiver = ctx.templateTypeChecker.getSymbolOfNode(node.receiver, component);
   if (
     symbolOfReceiver !== null &&
     symbolOfReceiver.kind === SymbolKind.Expression &&
-    isSignalReference(symbolOfReceiver)
+    isSignalReference(symbolOfReceiver, ctx.templateTypeChecker)
   ) {
     const templateMapping = ctx.templateTypeChecker.getSourceMappingAtTcbLocation(
       symbolOfReceiver.tcbLocation,

packages/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.ts

@@ -39,8 +39,8 @@ class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor<ErrorCo
     if (symbolLeft === null || symbolLeft.kind !== SymbolKind.Expression) {
       return [];
     }
-    const typeLeft = symbolLeft.tsType;
-    if (typeLeft.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+    const typeLeft = ctx.templateTypeChecker.getTypeOfSymbol(symbolLeft);
+    if (!typeLeft || typeLeft.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
       // We should not make assumptions about the any and unknown types; using a nullish coalescing
       // operator is acceptable for those.
       return [];

packages/compiler-cli/src/ngtsc/typecheck/extended/checks/optional_chain_not_nullable/index.ts

@@ -62,8 +62,8 @@ class OptionalChainNotNullableCheck extends TemplateCheckWithVisitor<ErrorCode.O
     if (symbolLeft === null || symbolLeft.kind !== SymbolKind.Expression) {
       return [];
     }
-    const typeLeft = symbolLeft.tsType;
-    if (typeLeft.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+    const typeLeft = ctx.templateTypeChecker.getTypeOfSymbol(symbolLeft);
+    if (!typeLeft || typeLeft.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
       // We should not make assumptions about the any and unknown types; using a nullish coalescing
       // operator is acceptable for those.
       return [];

packages/compiler-cli/src/ngtsc/typecheck/extended/checks/uninvoked_function_in_event_binding/index.ts

@@ -103,7 +103,8 @@ function assertExpressionInvoked(
   const symbol = ctx.templateTypeChecker.getSymbolOfNode(expression, component);
 
   if (symbol !== null && symbol.kind === SymbolKind.Expression) {
-    if (symbol.tsType.getCallSignatures()?.length > 0) {
+    const type = ctx.templateTypeChecker.getTypeOfSymbol(symbol);
+    if (type && type.getCallSignatures()?.length > 0) {
       const fullExpressionText = generateStringFromExpression(expression, expressionText);
       const errorString = formatExtendedError(
         ErrorCode.UNINVOKED_FUNCTION_IN_EVENT_BINDING,

packages/compiler-cli/src/ngtsc/typecheck/extended/checks/uninvoked_function_in_text_interpolation/index.ts

@@ -45,7 +45,8 @@ function assertExpressionInvoked(
   const symbol = ctx.templateTypeChecker.getSymbolOfNode(expression, component);
 
   if (symbol !== null && symbol.kind === SymbolKind.Expression) {
-    if (symbol.tsType.getCallSignatures()?.length > 0) {
+    const type = ctx.templateTypeChecker.getTypeOfSymbol(symbol);
+    if (type && type.getCallSignatures()?.length > 0) {
       const errorString = formatExtendedError(
         ErrorCode.UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION,
         `Function in text interpolation should be invoked: ${expression.name}()`,