Correctly report error when trying to reference template member without arguments

.chronus/changes/fix-ref-template-instance-member-2025-9-16-17-8-1.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+ - "@typespec/compiler"
+---
+
+Correctly report error when trying to reference member of template without using the arguments

packages/compiler/src/core/checker.ts

@@ -3027,11 +3027,15 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
  typeof options === "boolean"
  ? { ...defaultSymbolResolutionOptions, resolveDecorators: options }
  : { ...defaultSymbolResolutionOptions, ...(options ?? {}) };
- if (mapper === undefined && resolvedOptions.checkTemplateTypes && referenceSymCache.has(node)) {
+ if (
+ mapper === undefined &&
+ !resolvedOptions.resolveDeclarationOfTemplate &&
+ referenceSymCache.has(node)
+ ) {
  return referenceSymCache.get(node);
  }
  const sym = resolveTypeReferenceSymInternal(node, mapper, resolvedOptions);
- if (resolvedOptions.checkTemplateTypes) {
+ if (!resolvedOptions.resolveDeclarationOfTemplate) {
  referenceSymCache.set(node, sym);
  }
  return sym;
@@ -3102,6 +3106,12 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
  return undefined;
  }
  base = aliasedSym;
+ } else if (!options.resolveDeclarationOfTemplate && isTemplatedNode(getSymNode(base))) {
+ const baseSym = getContainerTemplateSymbol(base, node.base, mapper);
+ if (!baseSym) {
+ return undefined;
+ }
+ base = baseSym;
  }
  return resolveMemberInContainer(base, node, options);
  }
@@ -3226,23 +3236,58 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
 
  // Otherwise for templates we need to get the type and retrieve the late bound symbol.
  const aliasType = getTypeForNode(node as AliasStatementNode, mapper);
- if (isErrorType(aliasType)) {
+ return lateBindContainer(aliasType, aliasSymbol);
+ }
+
+ /** Check case where a template type member is referenced like
+ * ```
+ * model Foo<T> {t: T}
+ * model Test { t: Foo.t } // check `Foo` is correctly used as template
+ * ```
+ */
+ function getContainerTemplateSymbol(
+ sym: Sym,
+ node: MemberExpressionNode | IdentifierNode,
+ mapper: TypeMapper | undefined,
+ ): Sym | undefined {
+ if (pendingResolutions.has(sym, ResolutionKind.Type)) {
+ if (mapper === undefined) {
+ reportCheckerDiagnostic(
+ createDiagnostic({
+ code: "circular-alias-type",
+ format: { typeName: sym.name },
+ target: node,
+ }),
+ );
+ }
+ return undefined;
+ }
+
+ pendingResolutions.start(sym, ResolutionKind.Type);
+ const type = checkTypeReferenceSymbol(sym, node, mapper);
+ pendingResolutions.finish(sym, ResolutionKind.Type);
+
+ return lateBindContainer(type, sym);
+ }
+
+ function lateBindContainer(type: Type, sym: Sym) {
+ if (isErrorType(type)) {
  return undefined;
  }
- switch (aliasType.kind) {
+ switch (type.kind) {
  case "Model":
  case "Interface":
  case "Union":
- if (isTemplateInstance(aliasType)) {
+ if (isTemplateInstance(type)) {
  // this is an alias for some instantiation, so late-bind the instantiation
- lateBindMemberContainer(aliasType);
- return aliasType.symbol!;
+ lateBindMemberContainer(type);
+ return type.symbol!;
  }
  // fallthrough
  default:
  // get the symbol from the node aliased type's node, or just return the base
  // if it doesn't have a symbol (which will likely result in an error later on)
- return getMergedSymbol(aliasType.node!.symbol) ?? aliasSymbol;
+ return getMergedSymbol(type.node!.symbol) ?? sym;
  }
  }
 
@@ -5116,7 +5161,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
  */
  function checkAugmentDecorator(node: AugmentDecoratorStatementNode) {
  // This will validate the target type is pointing to a valid ref.
- resolveTypeReferenceSym(node.targetType, undefined);
+ resolveTypeReferenceSym(node.targetType, undefined, { resolveDeclarationOfTemplate: true });
  const links = resolver.getNodeLinks(node.targetType);
  if (links.isTemplateInstantiation) {
  program.reportDiagnostic(
@@ -5588,6 +5633,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
  ): Map<string, Operation> {
  const ownMembers = new Map<string, Operation>();
 
+ // Preregister each operation sym links instantiation to make sure there is no race condition when instantiating templated interface
+ for (const opNode of node.operations) {
+ const symbol = getSymbolForMember(opNode);
+ const links = symbol && getSymbolLinks(symbol);
+ if (links) {
+ links.instantiations = new TypeInstantiationMap();
+ }
+ }
  for (const opNode of node.operations) {
  const opType = checkOperation(opNode, mapper, interfaceType);
  if (ownMembers.has(opType.name)) {
@@ -6709,15 +6762,21 @@ interface SymbolResolutionOptions {
  resolveDecorators: boolean;
 
  /**
- * Should the symbol resolution instantiate templates and do a late bind of symbols.
- * @default true
+ * When resolving a symbol should it resolve to the declaration or template instance for ambiguous cases
+ * ```tsp
+ * model Foo<T = string> {}
+ * ```
+ *
+ * Does `Foo` reference to the `Foo<T>` or `Foo<string>` instance. By default it is the instance. Only case looking for declaration are augment decorator target
+ *
+ * @default false
  */
- checkTemplateTypes: boolean;
+ resolveDeclarationOfTemplate: boolean;
 }
 
 const defaultSymbolResolutionOptions: SymbolResolutionOptions = {
  resolveDecorators: false,
- checkTemplateTypes: true,
+ resolveDeclarationOfTemplate: false,
 };
 
 function printTypeReferenceNode(

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

@@ -10,6 +10,7 @@ import {
  createTestRunner,
  expectDiagnostics,
 } from "../../src/testing/index.js";
+import { Tester } from "../tester.js";
 
 describe("compiler: interfaces", () => {
  let testHost: TestHost;
@@ -250,6 +251,57 @@ describe("compiler: interfaces", () => {
  });
  });
 
+ it("report error if trying to instantiate a templated interface without providing type arguments", async () => {
+ const [{ pos }, diagnostics] = await Tester.compileAndDiagnose(`
+ interface Base<T> {
+ bar(): T;
+ }
+ op test is /*Base*/Base.bar;
+ `);
+
+ expectDiagnostics(diagnostics, {
+ code: "invalid-template-args",
+ message: "Template argument 'T' is required and not specified.",
+ pos: pos.Base.pos,
+ });
+ });
+
+ describe("report error if trying to reference another op in the same template", () => {
+ it("before", async () => {
+ const [{ pos }, diagnostics] = await Tester.compileAndDiagnose(`
+ interface Base<A> {
+ Custom<T>(): T;
+ Default is /*Base*/Base.Custom<A>;
+ }
+ `);
+
+ expectDiagnostics(diagnostics, [
+ {
+ code: "invalid-template-args",
+ message: "Template argument 'A' is required and not specified.",
+ pos: pos.Base.pos,
+ },
+ ]);
+ });
+
+ it("after", async () => {
+ const [{ pos }, diagnostics] = await Tester.compileAndDiagnose(`
+ interface Base<A> {
+ Default is /*Base*/Base.Custom<A>;
+ Custom<T>(): T;
+ }
+ `);
+
+ expectDiagnostics(diagnostics, [
+ {
+ code: "invalid-template-args",
+ message: "Template argument 'A' is required and not specified.",
+ pos: pos.Base.pos,
+ },
+ ]);
+ });
+ });
+
  describe("templated operations", () => {
  it("can instantiate template operation inside non-templated interface", async () => {
  const { Foo, bar } = (await runner.compile(`