Fix caching not complely accurate symbol (#2617)

This PR #2603 resolved an
issue where resolving meta types would cause types to be checked too
early but this broke some late bound symbol resolution.

It would return the declaration symbol when `checkTemplateTypes` is
false but would cache it. So in some cases it would then resolve the
wrong symbol later

common/changes/@typespec/compiler/fix-caching-invalid_2023-10-30-22-27.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@typespec/compiler",
+      "comment": "",
+      "type": "none"
+    }
+  ],
+  "packageName": "@typespec/compiler"
+}

packages/compiler/src/core/checker.ts

@@ -2152,16 +2152,17 @@ export function createChecker(program: Program): Checker {
     mapper: TypeMapper | undefined,
     options?: Partial<SymbolResolutionOptions> | boolean
   ): Sym | undefined {
-    if (mapper === undefined && referenceSymCache.has(node)) {
-      return referenceSymCache.get(node);
-    }
-
     const resolvedOptions: SymbolResolutionOptions =
       typeof options === "boolean"
         ? { ...defaultSymbolResolutionOptions, resolveDecorators: options }
         : { ...defaultSymbolResolutionOptions, ...(options ?? {}) };
+    if (mapper === undefined && resolvedOptions.checkTemplateTypes && referenceSymCache.has(node)) {
+      return referenceSymCache.get(node);
+    }
     const sym = resolveTypeReferenceSymInternal(node, mapper, resolvedOptions);
-    referenceSymCache.set(node, sym);
+    if (resolvedOptions.checkTemplateTypes) {
+      referenceSymCache.set(node, sym);
+    }
     return sym;
   }
 

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

@@ -438,6 +438,28 @@ describe("compiler: interfaces", () => {
         message: `Can't pass template arguments to non-templated type`,
       });
     });
+
+    // https://github.com/microsoft/typespec/pull/2617
+    it("can 'op is' a templated operation inside templated interface", async () => {
+      const { myBar } = (await runner.compile(`
+      interface Foo<A> {
+        bar<B>(input: A): B;
+      }
+
+      alias MyFoo = Foo<string>;
+      @test op myBar is MyFoo.bar<int32>;
+      `)) as {
+        myBar: Operation;
+      };
+
+      const input = myBar.parameters.properties.get("input")!.type;
+      strictEqual(input.kind, "Scalar" as const);
+      strictEqual(input.name, "string");
+
+      const returnType = myBar.returnType;
+      strictEqual(returnType.kind, "Scalar" as const);
+      strictEqual(returnType.name, "int32");
+    });
   });
 
   it("can decorate extended operations independently", async () => {