Fix: Infinite loop in language server due to not caching indeterminate entities (microsoft#5940)

fix microsoft#2964
The problem is everytime we created an indeterminate entity we created a
new object instead of caching it from the type. This meant everytime we
needed to reinstantiate the template it would create 2 separate
instances.
This caused an inifinite loop in the LSP as it would call getTypeForNode
for diagnostics

This should also solve some duplicate type issue we might have
encountered.

Author: timotheeguerin

.chronus/changes/fix-infinite-loop-diagnostic-2025-1-10-23-29-7.md

@@ -0,0 +1,8 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Fix: Infinite loop in language server due to not caching indeterminate entities in templates

packages/compiler/src/core/checker.ts

@@ -338,6 +338,7 @@ const TypeInstantiationMap = class
 
 export function createChecker(program: Program, resolver: NameResolver): Checker {
   const stdTypes: Partial<StdTypes> = {};
+  const indeterminateEntities = new WeakMap<Type, IndeterminateEntity>();
   const docFromCommentForSym = new Map<Sym, string>();
   const referenceSymCache = new WeakMap<
     TypeReferenceNode | MemberExpressionNode | IdentifierNode,
@@ -3390,10 +3391,17 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
   }
 
   function createIndeterminateEntity(type: IndeterminateEntity["type"]): IndeterminateEntity {
-    return {
+    const existing = indeterminateEntities.get(type);
+    if (existing) {
+      return existing;
+    }
+    const entity: IndeterminateEntity = {
       entityKind: "Indeterminate",
       type,
     };
+
+    indeterminateEntities.set(type, entity);
+    return entity;
   }
   function stringifyTypeForTemplate(type: Type): string | undefined {
     switch (type.kind) {
@@ -3448,24 +3456,15 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
   }
 
   function checkStringLiteral(str: StringLiteralNode): IndeterminateEntity {
-    return {
-      entityKind: "Indeterminate",
-      type: getLiteralType(str),
-    };
+    return createIndeterminateEntity(getLiteralType(str));
   }
 
   function checkNumericLiteral(num: NumericLiteralNode): IndeterminateEntity {
-    return {
-      entityKind: "Indeterminate",
-      type: getLiteralType(num),
-    };
+    return createIndeterminateEntity(getLiteralType(num));
   }
 
   function checkBooleanLiteral(bool: BooleanLiteralNode): IndeterminateEntity {
-    return {
-      entityKind: "Indeterminate",
-      type: getLiteralType(bool),
-    };
+    return createIndeterminateEntity(getLiteralType(bool));
   }
 
   function checkProgram() {

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

@@ -10,6 +10,7 @@ import {
   createTestRunner,
   expectDiagnosticEmpty,
   expectDiagnostics,
+  expectTypeEquals,
   extractCursor,
   extractSquiggles,
 } from "../../src/testing/index.js";
@@ -129,6 +130,22 @@ describe("compiler: templates", () => {
     expectDiagnosticEmpty(diagnostics);
   });
 
+  it("cache indeterminate types", async () => {
+    testHost.addTypeSpecFile(
+      "main.tsp",
+      `
+        model Template<T> {t: T}
+        @test model Test {
+          a: Template<"a">;
+          b: Template<"a">;
+        }
+      `,
+    );
+
+    const { Test } = (await testHost.compile("main.tsp")) as { Test: Model };
+    expectTypeEquals(Test.properties.get("a")!.type, Test.properties.get("b")!.type);
+  });
+
   it("allows default template parameters that are models", async () => {
     testHost.addTypeSpecFile(
       "main.tsp",