Fix: Property getting wrongly finished when used inside union expression or operation inside interface template (#7183)

fix  #7181

Author: timotheeguerin

.chronus/changes/fix-finishing-template-declarations-2025-3-30-17-1-23.md

@@ -0,0 +1,10 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Fix decorators on model properties getting wrongly called when checking the template declaration in the following cases
+ - inside a union expression
+ - under an non templated operation under a templated interface

packages/compiler/src/core/type-utils.ts

@@ -74,13 +74,22 @@ export function getParentTemplateNode(node: Node): (Node & TemplateDeclarationNo
   switch (node.kind) {
     case SyntaxKind.ModelStatement:
     case SyntaxKind.ScalarStatement:
-    case SyntaxKind.OperationStatement:
     case SyntaxKind.UnionStatement:
     case SyntaxKind.InterfaceStatement:
       return node.templateParameters.length > 0 ? node : undefined;
+    case SyntaxKind.OperationStatement:
+      return node.templateParameters.length > 0
+        ? node
+        : node.parent?.kind === SyntaxKind.InterfaceStatement
+          ? node.parent.templateParameters.length > 0
+            ? node.parent
+            : undefined
+          : undefined;
     case SyntaxKind.OperationSignatureDeclaration:
     case SyntaxKind.ModelProperty:
+    case SyntaxKind.UnionVariant:
     case SyntaxKind.ModelExpression:
+    case SyntaxKind.UnionExpression:
       return node.parent ? getParentTemplateNode(node.parent) : undefined;
     default:
       return undefined;

packages/compiler/test/checker/interface.test.ts

@@ -250,26 +250,6 @@ describe("compiler: interfaces", () => {
     });
   });
 
-  it("doesn't invoke decorators on uninstantiated templates", async () => {
-    const blues = new WeakSet();
-    let calls = 0;
-    testHost.addJsFile("dec.js", {
-      $blue(p: any, t: Type) {
-        calls++;
-        blues.add(t);
-      },
-    });
-    testHost.addTypeSpecFile(
-      "main.tsp",
-      `
-      import "./dec.js";
-      @blue interface A<T> { @blue foo(): int32}
-      `,
-    );
-    await testHost.compile("./");
-    strictEqual(calls, 0);
-  });
-
   describe("templated operations", () => {
     it("can instantiate template operation inside non-templated interface", async () => {
       const { Foo, bar } = (await runner.compile(`

packages/compiler/test/checker/model.test.ts

@@ -68,26 +68,6 @@ describe("compiler: models", () => {
     match(diagnostics[0].message, /Model already has a property/);
   });
 
-  it("doesn't invoke decorators on uninstantiated templates", async () => {
-    const blues = new WeakSet();
-    let calls = 0;
-    testHost.addJsFile("dec.js", {
-      $blue(p: any, t: Type) {
-        calls++;
-        blues.add(t);
-      },
-    });
-    testHost.addTypeSpecFile(
-      "main.tsp",
-      `
-      import "./dec.js";
-      @blue model A<T> { @blue x: int32}
-      `,
-    );
-    await testHost.compile("./");
-    strictEqual(calls, 0);
-  });
-
   it("emit single error when there is an invalid ref in a templated type", async () => {
     testHost.addTypeSpecFile(
       "main.tsp",

packages/compiler/test/checker/templates.test.ts

@@ -624,7 +624,7 @@ describe("compiler: templates", () => {
     });
   });
 
-  describe("doesn't run decorators on model properties when projecting template declarations", () => {
+  describe("doesn't run decorators when checking template declarations", () => {
     async function expectMarkDecoratorNotCalled(code: string) {
       testHost.addJsFile("mark.js", {
         $mark: () => fail("Should not have called decorator"),
@@ -643,40 +643,80 @@ describe("compiler: templates", () => {
 
     it("on model", async () => {
       await expectMarkDecoratorNotCalled(`
-          model Foo<T> {
-            @mark(T)
-            prop: string;
-          }
-        `);
+        @mark(T)
+        model Foo<T> {}
+      `);
+    });
+
+    it("on interface", async () => {
+      await expectMarkDecoratorNotCalled(`
+        @mark(T)
+        interface Foo<T> {}
+      `);
+    });
+
+    it("on operation", async () => {
+      await expectMarkDecoratorNotCalled(`
+        @mark(T)
+        op foo<T>(): void;
+      `);
     });
 
-    it("on model properties", async () => {
+    it("on union", async () => {
       await expectMarkDecoratorNotCalled(`
+        @mark(T)
+        union Foo<T> {}
+      `);
+    });
+
+    describe("on model properties", () => {
+      it("under model", async () => {
+        await expectMarkDecoratorNotCalled(`
           model Foo<T> {
             @mark(T)
             prop: string;
           }
         `);
-    });
+      });
 
-    it("on model properties (on operation)", async () => {
-      await expectMarkDecoratorNotCalled(`
+      it("under operation returnType", async () => {
+        await expectMarkDecoratorNotCalled(`
           op foo<T>(): {
             @mark(T)
             prop: string;
           };
         `);
-    });
+      });
 
-    it("on model properties (nested)", async () => {
-      await expectMarkDecoratorNotCalled(`
+      it("in operation in interface", async () => {
+        await expectMarkDecoratorNotCalled(`
+          interface Test<T> {
+            foo(@mark(T) prop: string;): void;
+          }
+        `);
+      });
+
+      it("nested", async () => {
+        await expectMarkDecoratorNotCalled(`
           model Foo<T> {
             nested: {
               @mark(T)
               prop: string;
             }
           }
         `);
+      });
+
+      it("nested in union", async () => {
+        await expectMarkDecoratorNotCalled(`
+          model Foo<T> {
+            nested: string | {
+              @mark(T)
+              prop: string;
+            }
+          }
+        `);
+      });
     });
   });