@angular/compiler-cli 20.3.4 → 20.3.5

package/bundles/{chunk-Y3D2VBHK.js → chunk-2WL2LMYD.js}

@@ -16,7 +16,7 @@ import {
   tryParseSignalInputMapping,
   tryParseSignalModelMapping,
   tryParseSignalQueryFromInitializer
-} from "./chunk-SZUJOV4Y.js";
+} from "./chunk-NR7S7ISS.js";
 
 // packages/compiler-cli/src/ngtsc/transform/jit/src/downlevel_decorators_transform.js
 import ts from "typescript";

package/bundles/chunk-BPDNYZBC.js

@@ -455,7 +455,7 @@ import { compileDirectiveFromMetadata, makeBindingParser, ParseLocation, ParseSo
 // packages/compiler-cli/linker/src/file_linker/partial_linkers/util.js
 import { createMayBeForwardRefExpression, outputAst as o2 } from "@angular/compiler";
 import semver from "semver";
-var PLACEHOLDER_VERSION = "20.3.4";
+var PLACEHOLDER_VERSION = "20.3.5";
 function wrapReference(wrapped) {
   return { value: wrapped, type: wrapped };
 }

package/bundles/{chunk-SZUJOV4Y.js → chunk-NR7S7ISS.js}

@@ -3144,8 +3144,8 @@ var StaticInterpreter = class {
     if (ts13.isIdentifier(node) || ts13.isStringLiteral(node) || ts13.isNumericLiteral(node)) {
       return node.text;
     } else if (ts13.isComputedPropertyName(node)) {
-      const literal3 = this.visitExpression(node.expression, context);
-      return typeof literal3 === "string" ? literal3 : void 0;
+      const literal4 = this.visitExpression(node.expression, context);
+      return typeof literal4 === "string" ? literal4 : void 0;
     } else {
       return void 0;
     }
@@ -7358,7 +7358,7 @@ var InjectableClassRegistry = class {
 // packages/compiler-cli/src/ngtsc/annotations/common/src/metadata.js
 import { ArrowFunctionExpr, LiteralArrayExpr, LiteralExpr as LiteralExpr2, literalMap, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
 import ts35 from "typescript";
-function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompiler, angularDecoratorTransform = (dec) => dec) {
+function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompiler, angularDecoratorTransform = (dec) => dec, undecoratedMetadataExtractor = () => null) {
   if (!reflection.isClass(clazz)) {
     return null;
   }
@@ -7379,15 +7379,41 @@ function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompi
     metaCtorParameters = new ArrowFunctionExpr([], new LiteralArrayExpr(ctorParameters));
   }
   let metaPropDecorators = null;
-  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && member.decorators !== null && member.decorators.length > 0 && // Private fields are not supported in the metadata emit
+  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && // Private fields are not supported in the metadata emit
   member.accessLevel !== ClassMemberAccessLevel.EcmaScriptPrivate);
-  const duplicateDecoratedMembers = classMembers.filter((member, i, arr) => arr.findIndex((arrayMember) => arrayMember.name === member.name) < i);
-  if (duplicateDecoratedMembers.length > 0) {
+  const decoratedMembers = [];
+  const seenMemberNames = /* @__PURE__ */ new Set();
+  let duplicateDecoratedMembers = null;
+  for (const member of classMembers) {
+    const shouldQuoteName = member.nameNode !== null && ts35.isStringLiteralLike(member.nameNode);
+    if (member.decorators !== null && member.decorators.length > 0) {
+      decoratedMembers.push({
+        key: member.name,
+        quoted: shouldQuoteName,
+        value: decoratedClassMemberToMetadata(member.decorators, isCore)
+      });
+      if (seenMemberNames.has(member.name)) {
+        duplicateDecoratedMembers ??= [];
+        duplicateDecoratedMembers.push(member);
+      } else {
+        seenMemberNames.add(member.name);
+      }
+    } else {
+      const undecoratedMetadata = undecoratedMetadataExtractor(member);
+      if (undecoratedMetadata !== null) {
+        decoratedMembers.push({
+          key: member.name,
+          quoted: shouldQuoteName,
+          value: undecoratedMetadata
+        });
+      }
+    }
+  }
+  if (duplicateDecoratedMembers !== null) {
     throw new FatalDiagnosticError(ErrorCode.DUPLICATE_DECORATED_PROPERTIES, duplicateDecoratedMembers[0].nameNode ?? clazz, `Duplicate decorated properties found on class '${clazz.name.text}': ` + duplicateDecoratedMembers.map((member) => member.name).join(", "));
   }
-  const decoratedMembers = classMembers.map((member) => classMemberToMetadata(member.nameNode ?? member.name, member.decorators, isCore));
   if (decoratedMembers.length > 0) {
-    metaPropDecorators = new WrappedNodeExpr4(ts35.factory.createObjectLiteralExpression(decoratedMembers));
+    metaPropDecorators = literalMap(decoratedMembers);
   }
   return {
     type: new WrappedNodeExpr4(id),
@@ -7408,10 +7434,9 @@ function ctorParameterToMetadata(param, isCore) {
   }
   return literalMap(mapEntries);
 }
-function classMemberToMetadata(name, decorators, isCore) {
-  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
-  const decoratorMeta = ts35.factory.createArrayLiteralExpression(ngDecorators);
-  return ts35.factory.createPropertyAssignment(name, decoratorMeta);
+function decoratedClassMemberToMetadata(decorators, isCore) {
+  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => new WrappedNodeExpr4(decoratorToMetadata(decorator)));
+  return new LiteralArrayExpr(ngDecorators);
 }
 function decoratorToMetadata(decorator, wrapFunctionsInParens) {
   if (decorator.identifier === null) {
@@ -8640,7 +8665,7 @@ import { compileClassMetadata, compileDeclareClassMetadata, compileDeclareDirect
 import ts65 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.js
-import { createMayBeForwardRefExpression as createMayBeForwardRefExpression2, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr6, ExternalReference as ExternalReference2, getSafePropertyAccessString, parseHostBindings, verifyHostBindings, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
+import { createMayBeForwardRefExpression as createMayBeForwardRefExpression2, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr6, ExternalReference as ExternalReference2, getSafePropertyAccessString, LiteralArrayExpr as LiteralArrayExpr2, literalMap as literalMap2, parseHostBindings, verifyHostBindings, R3Identifiers, ArrowFunctionExpr as ArrowFunctionExpr2, WrappedNodeExpr as WrappedNodeExpr6, literal as literal3 } from "@angular/compiler";
 import ts43 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/annotations/directive/src/initializer_function_access.js
@@ -9315,6 +9340,108 @@ function parseFieldStringArrayValue(directive, field, evaluator) {
   }
   return value;
 }
+function getDirectiveUndecoratedMetadataExtractor(reflector, importTracker) {
+  return (member) => {
+    const input = tryParseSignalInputMapping(member, reflector, importTracker);
+    if (input !== null) {
+      return getDecoratorMetaArray([
+        [new ExternalExpr6(R3Identifiers.inputDecorator), memberMetadataFromSignalInput(input)]
+      ]);
+    }
+    const output = tryParseInitializerBasedOutput(member, reflector, importTracker);
+    if (output !== null) {
+      return getDecoratorMetaArray([
+        [
+          new ExternalExpr6(R3Identifiers.outputDecorator),
+          memberMetadataFromInitializerOutput(output.metadata)
+        ]
+      ]);
+    }
+    const model = tryParseSignalModelMapping(member, reflector, importTracker);
+    if (model !== null) {
+      return getDecoratorMetaArray([
+        [
+          new ExternalExpr6(R3Identifiers.inputDecorator),
+          memberMetadataFromSignalInput(model.input)
+        ],
+        [
+          new ExternalExpr6(R3Identifiers.outputDecorator),
+          memberMetadataFromInitializerOutput(model.output)
+        ]
+      ]);
+    }
+    const query = tryParseSignalQueryFromInitializer(member, reflector, importTracker);
+    if (query !== null) {
+      let identifier;
+      if (query.name === "viewChild") {
+        identifier = R3Identifiers.viewChildDecorator;
+      } else if (query.name === "viewChildren") {
+        identifier = R3Identifiers.viewChildrenDecorator;
+      } else if (query.name === "contentChild") {
+        identifier = R3Identifiers.contentChildDecorator;
+      } else if (query.name === "contentChildren") {
+        identifier = R3Identifiers.contentChildrenDecorator;
+      } else {
+        return null;
+      }
+      return getDecoratorMetaArray([
+        [new ExternalExpr6(identifier), memberMetadataFromSignalQuery(query.call)]
+      ]);
+    }
+    return null;
+  };
+}
+function getDecoratorMetaArray(decorators) {
+  return new LiteralArrayExpr2(decorators.map(([type, args]) => literalMap2([
+    { key: "type", value: type, quoted: false },
+    { key: "args", value: args, quoted: false }
+  ])));
+}
+function memberMetadataFromSignalInput(input) {
+  return new LiteralArrayExpr2([
+    literalMap2([
+      {
+        key: "isSignal",
+        value: literal3(true),
+        quoted: false
+      },
+      {
+        key: "alias",
+        value: literal3(input.bindingPropertyName),
+        quoted: false
+      },
+      {
+        key: "required",
+        value: literal3(input.required),
+        quoted: false
+      }
+    ])
+  ]);
+}
+function memberMetadataFromInitializerOutput(output) {
+  return new LiteralArrayExpr2([literal3(output.bindingPropertyName)]);
+}
+function memberMetadataFromSignalQuery(call) {
+  const firstArg = call.arguments[0];
+  const firstArgMeta = ts43.isStringLiteralLike(firstArg) || ts43.isCallExpression(firstArg) ? new WrappedNodeExpr6(firstArg) : (
+    // If the first argument is a class reference, we need to wrap it in a `forwardRef`
+    // because the reference might occur after the current class. This wouldn't be flagged
+    // on the query initializer, because it executes after the class is initialized, whereas
+    // `setClassMetadata` runs immediately.
+    new ExternalExpr6(R3Identifiers.forwardRef).callFn([
+      new ArrowFunctionExpr2([], new WrappedNodeExpr6(firstArg))
+    ])
+  );
+  const entries = [
+    // We use wrapped nodes here, because the output AST doesn't support spread assignments.
+    firstArgMeta,
+    new WrappedNodeExpr6(ts43.factory.createObjectLiteralExpression([
+      ...call.arguments.length > 1 ? [ts43.factory.createSpreadAssignment(call.arguments[1])] : [],
+      ts43.factory.createPropertyAssignment("isSignal", ts43.factory.createTrue())
+    ]))
+  ];
+  return new LiteralArrayExpr2(entries);
+}
 function isStringArrayOrDie(value, name, node) {
   if (!Array.isArray(value)) {
     return false;
@@ -12171,11 +12298,11 @@ var ReferenceEmitEnvironment = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.js
-import { ExpressionType as ExpressionType2, R3Identifiers as R3Identifiers2, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
+import { ExpressionType as ExpressionType2, R3Identifiers as R3Identifiers3, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
 import ts54 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.js
-import { R3Identifiers } from "@angular/compiler";
+import { R3Identifiers as R3Identifiers2 } from "@angular/compiler";
 import ts53 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.js
@@ -12270,12 +12397,12 @@ var TypeParameterEmitter = class {
 import { BindingType, CssSelector as CssSelector2, makeBindingParser, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstHostElement, AbsoluteSourceSpan as AbsoluteSourceSpan2, ParseSpan, PropertyRead as PropertyRead2, ParsedEventType, Call, ThisReceiver, KeyedRead, LiteralPrimitive, RecursiveAstVisitor, ASTWithName, SafeCall, ImplicitReceiver as ImplicitReceiver2 } from "@angular/compiler";
 import ts52 from "typescript";
 var GUARD_COMMENT_TEXT = "hostBindingsBlockGuard";
-function createHostElement(type, selector, sourceNode, literal3, bindingDecorators, listenerDecorators) {
+function createHostElement(type, selector, sourceNode, literal4, bindingDecorators, listenerDecorators) {
   const bindings = [];
   const listeners = [];
   let parser = null;
-  if (literal3 !== null) {
-    for (const prop of literal3.properties) {
+  if (literal4 !== null) {
+    for (const prop of literal4.properties) {
       if (ts52.isPropertyAssignment(prop) && ts52.isStringLiteralLike(prop.initializer) && isStaticName(prop.name)) {
         parser ??= makeBindingParser();
         createNodeFromHostLiteralProperty(prop, parser, bindings, listeners);
@@ -12501,7 +12628,7 @@ var TCB_FILE_IMPORT_GRAPH_PREPARE_IDENTIFIERS = [
   // Imports may be added for signal input checking. We wouldn't want to change the
   // import graph for incremental compilations when suddenly a signal input is used,
   // or removed.
-  R3Identifiers.InputSignalBrandWriteType
+  R3Identifiers2.InputSignalBrandWriteType
 ];
 var TcbInliningRequirement;
 (function(TcbInliningRequirement2) {
@@ -12735,7 +12862,7 @@ function constructTypeCtorParameter(env, meta, rawType) {
   }
   if (signalInputKeys.length > 0) {
     const keyTypeUnion = ts54.factory.createUnionTypeNode(signalInputKeys);
-    const unwrapDirectiveSignalInputsExpr = env.referenceExternalType(R3Identifiers2.UnwrapDirectiveSignalInputs.moduleName, R3Identifiers2.UnwrapDirectiveSignalInputs.name, [
+    const unwrapDirectiveSignalInputsExpr = env.referenceExternalType(R3Identifiers3.UnwrapDirectiveSignalInputs.moduleName, R3Identifiers3.UnwrapDirectiveSignalInputs.name, [
       // TODO:
       new ExpressionType2(new WrappedNodeExpr7(rawType)),
       new ExpressionType2(new WrappedNodeExpr7(keyTypeUnion))
@@ -13142,7 +13269,7 @@ var TypeCheckShimGenerator = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.js
-import { BindingPipe, BindingType as BindingType2, Call as Call3, createCssSelectorFromNode, CssSelector as CssSelector3, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver3, ParsedEventType as ParsedEventType2, PropertyRead as PropertyRead4, R3Identifiers as R3Identifiers3, SafeCall as SafeCall2, SafePropertyRead as SafePropertyRead3, SelectorMatcher as SelectorMatcher2, ThisReceiver as ThisReceiver2, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundText, TmplAstContent, TmplAstDeferredBlock, TmplAstElement as TmplAstElement2, TmplAstForLoopBlock, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch, TmplAstLetDeclaration as TmplAstLetDeclaration2, TmplAstReference as TmplAstReference2, TmplAstSwitchBlock, TmplAstTemplate, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable, TmplAstHostElement as TmplAstHostElement2, TransplantedType, TmplAstComponent as TmplAstComponent2, TmplAstDirective as TmplAstDirective2, Binary } from "@angular/compiler";
+import { BindingPipe, BindingType as BindingType2, Call as Call3, createCssSelectorFromNode, CssSelector as CssSelector3, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver3, ParsedEventType as ParsedEventType2, PropertyRead as PropertyRead4, R3Identifiers as R3Identifiers4, SafeCall as SafeCall2, SafePropertyRead as SafePropertyRead3, SelectorMatcher as SelectorMatcher2, ThisReceiver as ThisReceiver2, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundText, TmplAstContent, TmplAstDeferredBlock, TmplAstElement as TmplAstElement2, TmplAstForLoopBlock, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch, TmplAstLetDeclaration as TmplAstLetDeclaration2, TmplAstReference as TmplAstReference2, TmplAstSwitchBlock, TmplAstTemplate, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable, TmplAstHostElement as TmplAstHostElement2, TransplantedType, TmplAstComponent as TmplAstComponent2, TmplAstDirective as TmplAstDirective2, Binary } from "@angular/compiler";
 import ts60 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/diagnostics.js
@@ -13329,8 +13456,8 @@ var AstTranslator = class {
   }
   visitLiteralArray(ast) {
     const elements = ast.expressions.map((expr) => this.translate(expr));
-    const literal3 = ts59.factory.createArrayLiteralExpression(elements);
-    const node = this.config.strictLiteralTypes ? literal3 : tsCastToAny(literal3);
+    const literal4 = ts59.factory.createArrayLiteralExpression(elements);
+    const node = this.config.strictLiteralTypes ? literal4 : tsCastToAny(literal4);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -13339,8 +13466,8 @@ var AstTranslator = class {
       const value = this.translate(ast.values[idx]);
       return ts59.factory.createPropertyAssignment(ts59.factory.createStringLiteral(key), value);
     });
-    const literal3 = ts59.factory.createObjectLiteralExpression(properties, true);
-    const node = this.config.strictLiteralTypes ? literal3 : tsCastToAny(literal3);
+    const literal4 = ts59.factory.createObjectLiteralExpression(properties, true);
+    const node = this.config.strictLiteralTypes ? literal4 : tsCastToAny(literal4);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -14111,9 +14238,9 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           target = this.dir.stringLiteralInputFields.has(fieldName) ? ts60.factory.createElementAccessExpression(dirId, ts60.factory.createStringLiteral(fieldName)) : ts60.factory.createPropertyAccessExpression(dirId, ts60.factory.createIdentifier(fieldName));
         }
         if (isSignal) {
-          const inputSignalBrandWriteSymbol = this.tcb.env.referenceExternalSymbol(R3Identifiers3.InputSignalBrandWriteType.moduleName, R3Identifiers3.InputSignalBrandWriteType.name);
+          const inputSignalBrandWriteSymbol = this.tcb.env.referenceExternalSymbol(R3Identifiers4.InputSignalBrandWriteType.moduleName, R3Identifiers4.InputSignalBrandWriteType.name);
           if (!ts60.isIdentifier(inputSignalBrandWriteSymbol) && !ts60.isPropertyAccessExpression(inputSignalBrandWriteSymbol)) {
-            throw new Error(`Expected identifier or property access for reference to ${R3Identifiers3.InputSignalBrandWriteType.name}`);
+            throw new Error(`Expected identifier or property access for reference to ${R3Identifiers4.InputSignalBrandWriteType.name}`);
           }
           target = ts60.factory.createElementAccessExpression(target, inputSignalBrandWriteSymbol);
         }
@@ -15624,7 +15751,7 @@ function widenBinding(expr, tcb) {
   }
 }
 function unwrapWritableSignal(expression, tcb) {
-  const unwrapRef = tcb.env.referenceExternalSymbol(R3Identifiers3.unwrapWritableSignal.moduleName, R3Identifiers3.unwrapWritableSignal.name);
+  const unwrapRef = tcb.env.referenceExternalSymbol(R3Identifiers4.unwrapWritableSignal.moduleName, R3Identifiers4.unwrapWritableSignal.name);
   return ts60.factory.createCallExpression(unwrapRef, void 0, [expression]);
 }
 var EVENT_PARAMETER = "$event";
@@ -16241,7 +16368,7 @@ var DirectiveSourceManager = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/template_symbol_builder.js
-import { AST, ASTWithName as ASTWithName2, ASTWithSource as ASTWithSource2, Binary as Binary2, BindingPipe as BindingPipe2, PropertyRead as PropertyRead5, R3Identifiers as R3Identifiers4, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute3, TmplAstBoundEvent as TmplAstBoundEvent3, TmplAstComponent as TmplAstComponent3, TmplAstDirective as TmplAstDirective3, TmplAstElement as TmplAstElement3, TmplAstLetDeclaration as TmplAstLetDeclaration3, TmplAstReference as TmplAstReference3, TmplAstTemplate as TmplAstTemplate2, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
+import { AST, ASTWithName as ASTWithName2, ASTWithSource as ASTWithSource2, Binary as Binary2, BindingPipe as BindingPipe2, PropertyRead as PropertyRead5, R3Identifiers as R3Identifiers5, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute3, TmplAstBoundEvent as TmplAstBoundEvent3, TmplAstComponent as TmplAstComponent3, TmplAstDirective as TmplAstDirective3, TmplAstElement as TmplAstElement3, TmplAstLetDeclaration as TmplAstLetDeclaration3, TmplAstReference as TmplAstReference3, TmplAstTemplate as TmplAstTemplate2, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
 import ts63 from "typescript";
 var SymbolBuilder = class {
   tcbPath;
@@ -16871,7 +16998,7 @@ function unwrapSignalInputWriteTAccessor(expr) {
   if (!ts63.isElementAccessExpression(expr) || !ts63.isPropertyAccessExpression(expr.argumentExpression)) {
     return null;
   }
-  if (!ts63.isIdentifier(expr.argumentExpression.name) || expr.argumentExpression.name.text !== R3Identifiers4.InputSignalBrandWriteType.name) {
+  if (!ts63.isIdentifier(expr.argumentExpression.name) || expr.argumentExpression.name.text !== R3Identifiers5.InputSignalBrandWriteType.name) {
     return null;
   }
   if (!ts63.isPropertyAccessExpression(expr.expression) && !ts63.isElementAccessExpression(expr.expression) && !ts63.isIdentifier(expr.expression)) {
@@ -16977,6 +17104,9 @@ var TemplateTypeCheckerImpl = class {
     const { data } = this.getLatestComponentState(directive, optimizeFor);
     return data?.hostElement ?? null;
   }
+  getDirectivesOfNode(component, node) {
+    return this.getLatestComponentState(component).data?.boundTarget.getDirectivesOfNode(node) ?? null;
+  }
   getUsedDirectives(component) {
     return this.getLatestComponentState(component).data?.boundTarget.getUsedDirectives() ?? null;
   }
@@ -18135,9 +18265,11 @@ var DirectiveDecoratorHandler = class {
     this.usePoisonedData = usePoisonedData;
     this.typeCheckHostBindings = typeCheckHostBindings;
     this.emitDeclarationOnly = emitDeclarationOnly;
+    this.undecoratedMetadataExtractor = getDirectiveUndecoratedMetadataExtractor(reflector, importTracker);
   }
   precedence = HandlerPrecedence.PRIMARY;
   name = "DirectiveDecoratorHandler";
+  undecoratedMetadataExtractor;
   detect(node, decorators) {
     if (!decorators) {
       const angularField = this.findClassFieldWithAngularFeatures(node);
@@ -18189,7 +18321,7 @@ var DirectiveDecoratorHandler = class {
         meta: analysis,
         hostDirectives: directiveResult.hostDirectives,
         rawHostDirectives: directiveResult.rawHostDirectives,
-        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler) : null,
+        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, void 0, this.undecoratedMetadataExtractor) : null,
         baseClass: readBaseClass(node, this.reflector, this.evaluator),
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, directiveResult.inputs, this.reflector),
         providersRequiringFactory,
@@ -18363,7 +18495,7 @@ var DirectiveDecoratorHandler = class {
 };
 
 // packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.js
-import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, ExternalExpr as ExternalExpr9, FactoryTarget as FactoryTarget2, FunctionExpr, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr2, R3Identifiers as R3Identifiers5, R3NgModuleMetadataKind, R3SelectorScopeMode, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr10 } from "@angular/compiler";
+import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, ExternalExpr as ExternalExpr9, FactoryTarget as FactoryTarget2, FunctionExpr, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr3, R3Identifiers as R3Identifiers6, R3NgModuleMetadataKind, R3SelectorScopeMode, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr10 } from "@angular/compiler";
 import ts67 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/annotations/ng_module/src/module_with_providers.js
@@ -18999,14 +19131,14 @@ var NgModuleDecoratorHandler = class {
           assertSuccessfulReferenceEmit(type, node, "pipe");
           return type.expression;
         });
-        const directiveArray = new LiteralArrayExpr2(directives);
-        const pipesArray = new LiteralArrayExpr2(pipes);
+        const directiveArray = new LiteralArrayExpr3(directives);
+        const pipesArray = new LiteralArrayExpr3(pipes);
         const directiveExpr = remoteScopesMayRequireCycleProtection && directives.length > 0 ? new FunctionExpr([], [new ReturnStatement(directiveArray)]) : directiveArray;
         const pipesExpr = remoteScopesMayRequireCycleProtection && pipes.length > 0 ? new FunctionExpr([], [new ReturnStatement(pipesArray)]) : pipesArray;
         const componentType = this.refEmitter.emit(decl, context);
         assertSuccessfulReferenceEmit(componentType, node, "component");
         const declExpr = componentType.expression;
-        const setComponentScope = new ExternalExpr9(R3Identifiers5.setComponentScope);
+        const setComponentScope = new ExternalExpr9(R3Identifiers6.setComponentScope);
         const callExpr = new InvokeFunctionExpr(setComponentScope, [
           declExpr,
           directiveExpr,
@@ -20080,10 +20212,12 @@ var ComponentDecoratorHandler = class {
       enableSelectorless: this.enableSelectorless,
       preserveSignificantWhitespace: this.i18nPreserveSignificantWhitespace
     };
+    this.undecoratedMetadataExtractor = getDirectiveUndecoratedMetadataExtractor(reflector, importTracker);
     this.canDeferDeps = !enableHmr;
   }
   literalCache = /* @__PURE__ */ new Map();
   elementSchemaRegistry = new DomElementSchemaRegistry3();
+  undecoratedMetadataExtractor;
   /**
    * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
    * any potential <link> tags which might need to be loaded. This cache ensures that work is not
@@ -20470,7 +20604,7 @@ var ComponentDecoratorHandler = class {
           relativeTemplatePath
         },
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
-        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template)) : null,
+        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template), this.undecoratedMetadataExtractor) : null,
         classDebugInfo: extractClassDebugInfo(
           node,
           this.reflector,

package/bundles/{chunk-WNPSVVUI.js → chunk-TFJ2HFCB.js}

@@ -4,7 +4,7 @@
     
 import {
   angularJitApplicationTransform
-} from "./chunk-Y3D2VBHK.js";
+} from "./chunk-2WL2LMYD.js";
 import {
   AbsoluteModuleStrategy,
   ActivePerfRecorder,
@@ -92,7 +92,7 @@ import {
   toUnredirectedSourceFile,
   tryParseInitializerApi,
   untagAllTsFiles
-} from "./chunk-SZUJOV4Y.js";
+} from "./chunk-NR7S7ISS.js";
 import {
   LogicalFileSystem,
   absoluteFrom,
@@ -2804,7 +2804,7 @@ var StandaloneComponentScopeReader = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/interpolated_signal_not_invoked/index.js
-import { ASTWithSource as ASTWithSource2, BindingType, Interpolation, PrefixNot, PropertyRead as PropertyRead2, TmplAstBoundAttribute, TmplAstIfBlock, TmplAstSwitchBlock } from "@angular/compiler";
+import { ASTWithSource as ASTWithSource2, BindingType, Interpolation, PrefixNot, PropertyRead as PropertyRead2, TmplAstBoundAttribute, TmplAstElement as TmplAstElement2, TmplAstIfBlock, TmplAstSwitchBlock, TmplAstTemplate as TmplAstTemplate2 } from "@angular/compiler";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/symbol_util.js
 import ts18 from "typescript";
@@ -2895,23 +2895,21 @@ var InterpolatedSignalCheck = class extends TemplateCheckWithVisitor {
   visitNode(ctx, component, node) {
     if (node instanceof Interpolation) {
       return node.expressions.map((item) => item instanceof PrefixNot ? item.expression : item).filter((item) => item instanceof PropertyRead2).flatMap((item) => buildDiagnosticForSignal(ctx, item, component));
-    } else if (node instanceof TmplAstBoundAttribute) {
-      const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
-      if (symbol?.kind === SymbolKind.Input && symbol.bindings.length > 0 && symbol.bindings.some((binding) => binding.target.kind === SymbolKind.Directive)) {
-        return [];
-      }
-      const nodeAst = isPropertyReadNodeAst(node);
-      if (
-        // a bound property like `[prop]="mySignal"`
-        (node.type === BindingType.Property || // or a class binding like `[class.myClass]="mySignal"`
-        node.type === BindingType.Class || // or a style binding like `[style.width]="mySignal"`
-        node.type === BindingType.Style || // or an attribute binding like `[attr.role]="mySignal"`
-        node.type === BindingType.Attribute || // or an animation binding like `[animate.enter]="mySignal"`
-        node.type === BindingType.Animation || // or an animation binding like `[@myAnimation]="mySignal"`
-        node.type === BindingType.LegacyAnimation) && nodeAst
-      ) {
-        return buildDiagnosticForSignal(ctx, nodeAst, component);
-      }
+    } else if (node instanceof TmplAstElement2 && node.inputs.length > 0) {
+      const directivesOfElement = ctx.templateTypeChecker.getDirectivesOfNode(component, node);
+      return node.inputs.flatMap((input) => checkBoundAttribute(ctx, component, directivesOfElement, input));
+    } else if (node instanceof TmplAstTemplate2 && node.tagName === "ng-template") {
+      const directivesOfElement = ctx.templateTypeChecker.getDirectivesOfNode(component, node);
+      const inputDiagnostics = node.inputs.flatMap((input) => {
+        return checkBoundAttribute(ctx, component, directivesOfElement, input);
+      });
+      const templateAttrDiagnostics = node.templateAttrs.flatMap((attr) => {
+        if (!(attr instanceof TmplAstBoundAttribute)) {
+          return [];
+        }
+        return checkBoundAttribute(ctx, component, directivesOfElement, attr);
+      });
+      return inputDiagnostics.concat(templateAttrDiagnostics);
     } else if (node instanceof TmplAstIfBlock) {
       return node.branches.map((branch) => branch.expression).filter((expr) => expr instanceof ASTWithSource2).map((expr) => {
         const ast = expr.ast;
@@ -2926,6 +2924,24 @@ var InterpolatedSignalCheck = class extends TemplateCheckWithVisitor {
     return [];
   }
 };
+function checkBoundAttribute(ctx, component, directivesOfElement, node) {
+  if (directivesOfElement !== null && directivesOfElement.some((dir) => dir.inputs.getByBindingPropertyName(node.name) !== null)) {
+    return [];
+  }
+  const nodeAst = isPropertyReadNodeAst(node);
+  if (
+    // a bound property like `[prop]="mySignal"`
+    (node.type === BindingType.Property || // or a class binding like `[class.myClass]="mySignal"`
+    node.type === BindingType.Class || // or a style binding like `[style.width]="mySignal"`
+    node.type === BindingType.Style || // or an attribute binding like `[attr.role]="mySignal"`
+    node.type === BindingType.Attribute || // or an animation binding like `[animate.enter]="mySignal"`
+    node.type === BindingType.Animation || // or an animation binding like `[@myAnimation]="mySignal"`
+    node.type === BindingType.LegacyAnimation) && nodeAst
+  ) {
+    return buildDiagnosticForSignal(ctx, nodeAst, component);
+  }
+  return [];
+}
 function isPropertyReadNodeAst(node) {
   if (node.value instanceof ASTWithSource2 === false) {
     return void 0;
@@ -2952,8 +2968,11 @@ function buildDiagnosticForSignal(ctx, node, component) {
     const diagnostic = ctx.makeTemplateDiagnostic(templateMapping.span, errorString);
     return [diagnostic];
   }
+  if (!isFunctionInstanceProperty(node.name) && !isSignalInstanceProperty(node.name)) {
+    return [];
+  }
   const symbolOfReceiver = ctx.templateTypeChecker.getSymbolOfNode(node.receiver, component);
-  if ((isFunctionInstanceProperty(node.name) || isSignalInstanceProperty(node.name)) && symbolOfReceiver !== null && symbolOfReceiver.kind === SymbolKind.Expression && isSignalReference(symbolOfReceiver)) {
+  if (symbolOfReceiver !== null && symbolOfReceiver.kind === SymbolKind.Expression && isSignalReference(symbolOfReceiver)) {
     const templateMapping = ctx.templateTypeChecker.getSourceMappingAtTcbLocation(symbolOfReceiver.tcbLocation);
     const errorString = `${node.receiver.name} is a function and should be invoked: ${node.receiver.name}()`;
     const diagnostic = ctx.makeTemplateDiagnostic(templateMapping.span, errorString);
@@ -2991,7 +3010,7 @@ var factory2 = {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/missing_control_flow_directive/index.js
-import { TmplAstTemplate as TmplAstTemplate2 } from "@angular/compiler";
+import { TmplAstTemplate as TmplAstTemplate3 } from "@angular/compiler";
 var KNOWN_CONTROL_FLOW_DIRECTIVES = /* @__PURE__ */ new Map([
   ["ngIf", { directive: "NgIf", builtIn: "@if" }],
   ["ngFor", { directive: "NgFor", builtIn: "@for" }],
@@ -3008,7 +3027,7 @@ var MissingControlFlowDirectiveCheck = class extends TemplateCheckWithVisitor {
     return super.run(ctx, component, template);
   }
   visitNode(ctx, component, node) {
-    if (!(node instanceof TmplAstTemplate2))
+    if (!(node instanceof TmplAstTemplate3))
       return [];
     const controlFlowAttr = node.templateAttrs.find((attr) => KNOWN_CONTROL_FLOW_DIRECTIVES.has(attr.name));
     if (!controlFlowAttr)
@@ -3033,12 +3052,12 @@ var factory3 = {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/missing_ngforof_let/index.js
-import { TmplAstTemplate as TmplAstTemplate3 } from "@angular/compiler";
+import { TmplAstTemplate as TmplAstTemplate4 } from "@angular/compiler";
 var MissingNgForOfLetCheck = class extends TemplateCheckWithVisitor {
   code = ErrorCode.MISSING_NGFOROF_LET;
   visitNode(ctx, component, node) {
-    const isTemplate = node instanceof TmplAstTemplate3;
-    if (!(node instanceof TmplAstTemplate3)) {
+    const isTemplate = node instanceof TmplAstTemplate4;
+    if (!(node instanceof TmplAstTemplate4)) {
       return [];
     }
     if (node.templateAttrs.length === 0) {
@@ -3063,7 +3082,7 @@ var factory4 = {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/missing_structural_directive/index.js
-import { TmplAstTemplate as TmplAstTemplate4 } from "@angular/compiler";
+import { TmplAstTemplate as TmplAstTemplate5 } from "@angular/compiler";
 var KNOWN_CONTROL_FLOW_DIRECTIVES2 = /* @__PURE__ */ new Set([
   "ngIf",
   "ngFor",
@@ -3082,7 +3101,7 @@ var MissingStructuralDirectiveCheck = class extends TemplateCheckWithVisitor {
     return super.run(ctx, component, template);
   }
   visitNode(ctx, component, node) {
-    if (!(node instanceof TmplAstTemplate4))
+    if (!(node instanceof TmplAstTemplate5))
       return [];
     const customStructuralDirective = node.templateAttrs.find((attr) => !KNOWN_CONTROL_FLOW_DIRECTIVES2.has(attr.name));
     if (!customStructuralDirective)

package/bundles/{chunk-JKYMLCNY.js → chunk-ZE3ZGBK3.js}

@@ -12,7 +12,7 @@ import {
   formatDiagnostics,
   performCompilation,
   readConfiguration
-} from "./chunk-WNPSVVUI.js";
+} from "./chunk-TFJ2HFCB.js";
 
 // packages/compiler-cli/src/main.js
 import ts2 from "typescript";

package/bundles/index.js

@@ -28,7 +28,7 @@ import {
   isTsDiagnostic,
   performCompilation,
   readConfiguration
-} from "./chunk-WNPSVVUI.js";
+} from "./chunk-TFJ2HFCB.js";
 import {
   ConsoleLogger,
   LogLevel
@@ -37,7 +37,7 @@ import {
   angularJitApplicationTransform,
   getDownlevelDecoratorsTransform,
   getInitializerApiJitTransform
-} from "./chunk-Y3D2VBHK.js";
+} from "./chunk-2WL2LMYD.js";
 import {
   ActivePerfRecorder,
   ErrorCode,
@@ -46,7 +46,7 @@ import {
   TsCreateProgramDriver,
   isLocalCompilationDiagnostics,
   ngErrorCode
-} from "./chunk-SZUJOV4Y.js";
+} from "./chunk-NR7S7ISS.js";
 import "./chunk-I2BHWRAU.js";
 import {
   InvalidFileSystem,
@@ -77,7 +77,7 @@ import "./chunk-G7GFT6BU.js";
 
 // packages/compiler-cli/src/version.js
 import { Version } from "@angular/compiler";
-var VERSION = new Version("20.3.4");
+var VERSION = new Version("20.3.5");
 
 // packages/compiler-cli/private/tooling.js
 var GLOBAL_DEFS_FOR_TERSER = {

package/bundles/private/migrations.js

@@ -13,7 +13,7 @@ import {
   TypeScriptReflectionHost,
   createForwardRefResolver,
   reflectObjectLiteral
-} from "../chunk-SZUJOV4Y.js";
+} from "../chunk-NR7S7ISS.js";
 import "../chunk-I2BHWRAU.js";
 import "../chunk-GWZQLAGK.js";
 import "../chunk-XYYEESKY.js";

package/bundles/private/tooling.js

@@ -4,8 +4,8 @@
     
 import {
   angularJitApplicationTransform
-} from "../chunk-Y3D2VBHK.js";
-import "../chunk-SZUJOV4Y.js";
+} from "../chunk-2WL2LMYD.js";
+import "../chunk-NR7S7ISS.js";
 import "../chunk-I2BHWRAU.js";
 import "../chunk-GWZQLAGK.js";
 import "../chunk-XYYEESKY.js";

package/bundles/src/bin/ng_xi18n.js

@@ -6,12 +6,12 @@
 import {
   main,
   readCommandLineAndConfiguration
-} from "../../chunk-JKYMLCNY.js";
+} from "../../chunk-ZE3ZGBK3.js";
 import {
   EmitFlags
-} from "../../chunk-WNPSVVUI.js";
-import "../../chunk-Y3D2VBHK.js";
-import "../../chunk-SZUJOV4Y.js";
+} from "../../chunk-TFJ2HFCB.js";
+import "../../chunk-2WL2LMYD.js";
+import "../../chunk-NR7S7ISS.js";
 import "../../chunk-I2BHWRAU.js";
 import {
   setFileSystem

package/bundles/src/bin/ngc.js

@@ -5,10 +5,10 @@
     
 import {
   main
-} from "../../chunk-JKYMLCNY.js";
-import "../../chunk-WNPSVVUI.js";
-import "../../chunk-Y3D2VBHK.js";
-import "../../chunk-SZUJOV4Y.js";
+} from "../../chunk-ZE3ZGBK3.js";
+import "../../chunk-TFJ2HFCB.js";
+import "../../chunk-2WL2LMYD.js";
+import "../../chunk-NR7S7ISS.js";
 import "../../chunk-I2BHWRAU.js";
 import {
   setFileSystem

package/linker/src/file_linker/partial_linkers/util.d.ts

@@ -7,7 +7,7 @@
  */
 import { MaybeForwardRefExpression, outputAst as o, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference } from '@angular/compiler';
 import { AstObject, AstValue } from '../../ast/ast_value';
-export declare const PLACEHOLDER_VERSION = "20.3.4";
+export declare const PLACEHOLDER_VERSION = "20.3.5";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "20.3.4",
+  "version": "20.3.5",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -48,7 +48,7 @@
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "@angular/compiler": "20.3.4",
+    "@angular/compiler": "20.3.5",
     "typescript": ">=5.8 <6.0"
   },
   "peerDependenciesMeta": {

package/src/ngtsc/annotations/common/src/metadata.d.ts

@@ -5,9 +5,11 @@
  * 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
  */
-import { R3ClassMetadata } from '@angular/compiler';
+import { LiteralArrayExpr, R3ClassMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
+import { ClassMember, DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
+/** Function that extracts metadata from an undercorated class member. */
+export type UndecoratedMetadataExtractor = (member: ClassMember) => LiteralArrayExpr | null;
 /**
  * Given a class declaration, generate a call to `setClassMetadata` with the Angular metadata
  * present on the class or its member fields. An ngDevMode guard is used to allow the call to be
@@ -16,7 +18,7 @@ import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection'
  * If no such metadata is present, this function returns `null`. Otherwise, the call is returned
  * as a `Statement` for inclusion along with the class.
  */
-export declare function extractClassMetadata(clazz: DeclarationNode, reflection: ReflectionHost, isCore: boolean, annotateForClosureCompiler?: boolean, angularDecoratorTransform?: (dec: Decorator) => Decorator): R3ClassMetadata | null;
+export declare function extractClassMetadata(clazz: DeclarationNode, reflection: ReflectionHost, isCore: boolean, annotateForClosureCompiler?: boolean, angularDecoratorTransform?: (dec: Decorator) => Decorator, undecoratedMetadataExtractor?: UndecoratedMetadataExtractor): R3ClassMetadata | null;
 /**
  * Recursively recreates all of the `Identifier` descendant nodes with a particular name inside
  * of an AST node, thus removing any references to them. Useful if a particular node has to be

package/src/ngtsc/annotations/component/src/handler.d.ts

@@ -79,6 +79,7 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, strictCtorDeps: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean, enableLetSyntax: boolean, externalRuntimeStyles: boolean, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, jitDeclarationRegistry: JitDeclarationRegistry, i18nPreserveSignificantWhitespace: boolean, strictStandalone: boolean, enableHmr: boolean, implicitStandaloneValue: boolean, typeCheckHostBindings: boolean, enableSelectorless: boolean, emitDeclarationOnly: boolean);
     private literalCache;
     private elementSchemaRegistry;
+    private readonly undecoratedMetadataExtractor;
     /**
      * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
      * any potential <link> tags which might need to be loaded. This cache ensures that work is not

package/src/ngtsc/annotations/directive/src/handler.d.ts

@@ -65,6 +65,7 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, typeCheckScopeRegistry: TypeCheckScopeRegistry, compilationMode: CompilationMode, jitDeclarationRegistry: JitDeclarationRegistry, resourceRegistry: ResourceRegistry, strictStandalone: boolean, implicitStandaloneValue: boolean, usePoisonedData: boolean, typeCheckHostBindings: boolean, emitDeclarationOnly: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "DirectiveDecoratorHandler";
+    private readonly undecoratedMetadataExtractor;
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator | null>): AnalysisOutput<DirectiveHandlerData>;
     symbol(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): DirectiveSymbol;

package/src/ngtsc/annotations/directive/src/shared.d.ts

@@ -12,7 +12,7 @@ import { ClassPropertyMapping, DecoratorInputTransform, HostDirectiveMeta, Input
 import { DynamicValue, PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
-import { ReferencesRegistry } from '../../common';
+import { ReferencesRegistry, UndecoratedMetadataExtractor } from '../../common';
 type QueryDecoratorName = 'ViewChild' | 'ViewChildren' | 'ContentChild' | 'ContentChildren';
 export declare const queryDecoratorNames: QueryDecoratorName[];
 export interface HostBindingNodes {
@@ -43,6 +43,11 @@ export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decora
 export declare function extractDecoratorQueryMetadata(exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string, reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata;
 export declare function parseDirectiveStyles(directive: Map<string, ts.Expression>, evaluator: PartialEvaluator, compilationMode: CompilationMode): null | string[];
 export declare function parseFieldStringArrayValue(directive: Map<string, ts.Expression>, field: string, evaluator: PartialEvaluator): null | string[];
+/**
+ * Returns a function that can be used to extract data for the `setClassMetadata`
+ * calls from undecorated directive class members.
+ */
+export declare function getDirectiveUndecoratedMetadataExtractor(reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): UndecoratedMetadataExtractor;
 /**
  * Parses the `transform` function and its type for a decorator `@Input`.
  *

package/src/ngtsc/typecheck/api/checker.d.ts

@@ -204,6 +204,10 @@ export interface TemplateTypeChecker {
      * Retrieve the type checking engine's metadata for the given pipe class, if available.
      */
     getPipeMetadata(pipe: ts.ClassDeclaration): PipeMeta | null;
+    /**
+     * Gets the directives that apply to the given template node in a component's template.
+     */
+    getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;
     /**
      * Gets the directives that have been used in a component's template.
      */

package/src/ngtsc/typecheck/src/checker.d.ts

@@ -78,6 +78,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, localMetaReader: MetadataReaderWithIndex, ngModuleIndex: NgModuleIndex, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
     getTemplate(component: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstNode[] | null;
     getHostElement(directive: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstHostElement | null;
+    getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;
     getUsedDirectives(component: ts.ClassDeclaration): TypeCheckableDirectiveMeta[] | null;
     getUsedPipes(component: ts.ClassDeclaration): string[] | null;
     private getLatestComponentState;