Fix: Interface with templated operation causing crash if defined after use

common/changes/@typespec/compiler/fix-interface-factory-crash_2023-04-10-17-28.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@typespec/compiler",
+      "comment": "Fix: Interface with templated operation causing crash if defined after use",
+      "type": "none"
+    }
+  ],
+  "packageName": "@typespec/compiler"
+}

packages/compiler/core/checker.ts

@@ -1083,7 +1083,11 @@ export function createChecker(program: Program): Checker {
       return sym.type as TemplatedType;
     }
 
-    return checkDeclaredType(sym, decl, mapper) as TemplatedType;
+    if (sym.flags & SymbolFlags.Member) {
+      return checkMemberSym(sym, mapper) as TemplatedType;
+    } else {
+      return checkDeclaredType(sym, decl, mapper) as TemplatedType;
+    }
   }
 
   /**

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

@@ -317,6 +317,35 @@ describe("compiler: interfaces", () => {
       strictEqual(returnType.name, "int32");
     });
 
+    it("can instantiate template operation inside templated interface (inverted order)", async () => {
+      const { Foo, bar } = (await runner.compile(`
+      alias Bar = MyFoo.bar<int32>;
+
+      alias MyFoo = Foo<string>;
+
+      @test interface Foo<A> {
+        @test bar<B>(input: A): B;
+      }
+      `)) as {
+        Foo: Interface;
+        bar: Operation;
+      };
+
+      strictEqual(Foo.operations.size, 1);
+      ok(
+        isTemplateDeclaration(Foo.operations.get("bar")!),
+        "Operation inside MyFoo interface is still a template"
+      );
+
+      const input = bar.parameters.properties.get("input")!.type;
+      strictEqual(input.kind, "Scalar" as const);
+      strictEqual(input.name, "string");
+
+      const returnType = bar.returnType;
+      strictEqual(returnType.kind, "Scalar" as const);
+      strictEqual(returnType.name, "int32");
+    });
+
     it("cache templated operations", async () => {
       const { Index } = (await runner.compile(`
       @test interface Foo<A> {