fix(compiler): correct type names for declaration expressions

Anonymous declarations used in expression position rendered with a stray
namespace prefix (e.g. `Ns.` for enum/scalar, `Ns.{ x: string }` for
keyword-form model). Render them inline and un-prefixed, mirroring union
expression naming.

Also extract a single shared `isDeclarationInExpressionPosition` helper used
by both the binder and checker so the two position predicates cannot drift,
and add regression tests (type names, keyword-form union as `|` operand,
template parameter referenced inside an expression declaration).

Author: timotheeguerin

packages/compiler/src/core/binder.ts

@@ -1,6 +1,7 @@
 import { mutate } from "../utils/misc.js";
 import { compilerAssert } from "./diagnostics.js";
 import { getLocationContext } from "./helpers/location-context.js";
+import { isDeclarationInExpressionPosition } from "./helpers/syntax-utils.js";
 import { visitChildren } from "./parser.js";
 import type { Program } from "./program.js";
 import {
@@ -397,12 +398,7 @@ export function createBinder(program: Program): Binder {
    * position. Anonymous declarations are always in expression position.
    */
   function isDeclarationStatementPosition(node: Node): boolean {
-    const parent = node.parent;
-    return (
-      parent?.kind === SyntaxKind.NamespaceStatement ||
-      parent?.kind === SyntaxKind.TypeSpecScript ||
-      parent?.kind === SyntaxKind.JsSourceFile
-    );
+    return !isDeclarationInExpressionPosition(node);
   }
 
   function bindModelStatement(node: ModelStatementNode) {

packages/compiler/src/core/checker.ts

@@ -21,6 +21,7 @@ import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-
 import { getLocationContext } from "./helpers/location-context.js";
 import { explainStringTemplateNotSerializable } from "./helpers/string-template-utils.js";
 import {
+  isDeclarationInExpressionPosition,
   printIdentifier,
   printMemberExpressionPath,
   typeReferenceToString,
@@ -5006,22 +5007,6 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
     }
   }
 
-  /**
-   * Determine whether a declaration node (model/enum/union/scalar) appears in
-   * expression position (e.g. as the value of an alias or a property type) rather
-   * than as a top-level statement in a namespace or file. Anonymous declarations
-   * (without an `id`) are always in expression position.
-   */
-  function isDeclarationInExpressionPosition(
-    node: ModelStatementNode | EnumStatementNode | UnionStatementNode | ScalarStatementNode,
-  ): boolean {
-    const parent = node.parent;
-    return (
-      parent === undefined ||
-      (parent.kind !== SyntaxKind.NamespaceStatement && parent.kind !== SyntaxKind.TypeSpecScript)
-    );
-  }
-
   /**
    * A declaration used in expression position is anonymous and cannot be referenced or
    * instantiated, so template parameters on it are meaningless. Report a diagnostic when present.

packages/compiler/src/core/helpers/syntax-utils.ts

@@ -1,6 +1,31 @@
 import { CharCode, isIdentifierContinue, isIdentifierStart, utf16CodeUnits } from "../charcode.js";
 import { isModifier, Keywords, ReservedKeywords } from "../scanner.js";
-import { IdentifierNode, MemberExpressionNode, SyntaxKind, TypeReferenceNode } from "../types.js";
+import {
+  IdentifierNode,
+  MemberExpressionNode,
+  Node,
+  SyntaxKind,
+  TypeReferenceNode,
+} from "../types.js";
+
+/**
+ * Determine whether a declaration node (model/enum/union/scalar) appears in expression
+ * position (e.g. as an alias value or a property type) rather than as a top-level
+ * statement directly under a namespace or source file. Anonymous declarations (used as
+ * expressions) are always in expression position.
+ *
+ * This is the single source of truth shared by the binder and checker so the two cannot
+ * drift apart.
+ */
+export function isDeclarationInExpressionPosition(node: Node): boolean {
+  const parent = node.parent;
+  return (
+    parent === undefined ||
+    (parent.kind !== SyntaxKind.NamespaceStatement &&
+      parent.kind !== SyntaxKind.TypeSpecScript &&
+      parent.kind !== SyntaxKind.JsSourceFile)
+  );
+}
 
 /**
  * Print a string as a TypeSpec identifier. If the string is a valid identifier, return it as is otherwise wrap it into backticks.

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

@@ -162,18 +162,31 @@ function getNamespacePrefix(type: Namespace | undefined, options?: TypeNameOptio
 }
 
 function getEnumName(e: Enum, options: TypeNameOptions | undefined): string {
-  return `${getNamespacePrefix(e.namespace, options)}${getIdentifierName(e.name, options)}`;
+  // An enum used in expression position is anonymous; render its members inline
+  // instead of a (namespace-prefixed) name.
+  if (e.name === "") {
+    return `{ ${[...e.members.values()].map((m) => m.name).join(", ")} }`;
+  }
+  const nsPrefix = e.expression ? "" : getNamespacePrefix(e.namespace, options);
+  return `${nsPrefix}${getIdentifierName(e.name, options)}`;
 }
 
 function getScalarName(scalar: Scalar, options: TypeNameOptions | undefined): string {
-  return `${getNamespacePrefix(scalar.namespace, options)}${getIdentifierName(
-    scalar.name,
-    options,
-  )}`;
+  // A scalar used in expression position is anonymous; render what it extends
+  // (there is no inline literal syntax for it) instead of a namespace-only name.
+  if (scalar.name === "") {
+    return scalar.baseScalar
+      ? `scalar extends ${getTypeName(scalar.baseScalar, options)}`
+      : "scalar";
+  }
+  const nsPrefix = scalar.expression ? "" : getNamespacePrefix(scalar.namespace, options);
+  return `${nsPrefix}${getIdentifierName(scalar.name, options)}`;
 }
 
 function getModelName(model: Model, options: TypeNameOptions | undefined) {
-  const nsPrefix = getNamespacePrefix(model.namespace, options);
+  // Declarations used in expression position are anonymous and not addressable, so
+  // they should not be namespace-qualified (mirrors union expression naming).
+  const nsPrefix = model.expression ? "" : getNamespacePrefix(model.namespace, options);
   if (model.name === "" && model.properties.size === 0) {
     return "{}";
   }

packages/compiler/test/checker/declaration-expressions.test.ts

@@ -68,6 +68,23 @@ describe("union", () => {
     expect(type.variants.has("bar")).toBe(true);
   });
 
+  it("keeps its members when used as a `|` operand instead of being flattened", async () => {
+    // Regression: a keyword-form union is `expression: true`; it must not be flattened
+    // into the parent `|` union (which would silently drop colliding named variants).
+    const { Foo } = await Tester.compile(t.code`
+      model ${t.model("Foo")} {
+        value: union { a: "a1", b: "b1" } | union { a: "a2", c: "c1" };
+      }
+    `);
+    const type = Foo.properties.get("value")!.type as Union;
+    expect(type.kind).toBe("Union");
+    expect(type.variants.size).toBe(2);
+    for (const variant of type.variants.values()) {
+      expect((variant.type as Union).kind).toBe("Union");
+      expect((variant.type as Union).variants.size).toBe(2);
+    }
+  });
+
   it("is not registered in the namespace", async () => {
     const { program } = await Tester.compile(`
       namespace Ns;
@@ -246,6 +263,21 @@ describe("usage contexts", () => {
     expect((Foo.properties.get("m")!.type as Model).expression).toBe(true);
   });
 
+  it("can reference an enclosing template parameter", async () => {
+    const { Bar } = await Tester.compile(t.code`
+      model Wrapper<T> {
+        nested: model { item: T };
+      }
+      model ${t.model("Bar")} {
+        w: Wrapper<int32>;
+      }
+    `);
+    const wrapper = Bar.properties.get("w")!.type as Model;
+    const nested = wrapper.properties.get("nested")!.type as Model;
+    expect(nested.expression).toBe(true);
+    expect((nested.properties.get("item")!.type as Scalar).name).toBe("int32");
+  });
+
   it("can be used as an operation return type", async () => {
     const { test } = await Tester.compile(t.code`
       op ${t.op("test")}(): enum { a, b };
@@ -313,14 +345,29 @@ describe("usage contexts", () => {
 });
 
 describe("type name", () => {
-  it("renders an anonymous expression with an empty name", async () => {
+  it("renders anonymous expressions inline and is not namespace-qualified", async () => {
     const { Foo } = await Tester.compile(t.code`
+      namespace Ns;
+      model ${t.model("Foo")} {
+        modelProp: model { x: string };
+        enumProp: enum { a, b };
+        scalarProp: scalar extends string;
+        unionProp: union { string, int32 };
+      }
+    `);
+    expect(getTypeName(Foo.properties.get("modelProp")!.type)).toBe("{ x: string }");
+    expect(getTypeName(Foo.properties.get("enumProp")!.type)).toBe("{ a, b }");
+    expect(getTypeName(Foo.properties.get("scalarProp")!.type)).toBe("scalar extends string");
+    expect(getTypeName(Foo.properties.get("unionProp")!.type)).toBe("string | int32");
+  });
+
+  it("renders a named expression by its name without a namespace prefix", async () => {
+    const { Foo } = await Tester.compile(t.code`
+      namespace Ns;
       model ${t.model("Foo")} {
-        anon: enum { a, b };
         named: enum Color { red };
       }
     `);
-    expect(getTypeName(Foo.properties.get("anon")!.type)).toBe("");
     expect(getTypeName(Foo.properties.get("named")!.type)).toBe("Color");
   });
 });