Keep is/extends inline for multi-argument template heritage

A model/scalar heritage clause (`is X` / `extends X`) wrapped the keyword and
the template reference in one `group(indent(...))`. Prettier measures that
group against the full flat width of the template argument list, so it broke
and pushed the keyword onto its own indented line even when the declaration
line was short:

    model Picked
      is PickProperties<
        Sample,
        ...
      >;

`printHeritageClause` now keeps the keyword inline when the base is a template
reference with multiple (breakable) arguments, letting the argument list
control the line break:

    model Picked is PickProperties<
      Sample,
      ...
    >;

Single-argument and non-template bases keep breaking the keyword when the
declaration is too long.

Fixes the `is`-breaking part of #11009.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: oha-4

.chronus/changes/fix-formatter-heritage-keyword-break-2026-6-18.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Keep the `is`/`extends` keyword on the declaration line when the base is a template reference with multiple arguments. The template argument list now controls the line breaking instead of the keyword being pushed onto its own indented line.

packages/compiler/src/formatter/print/printer.ts

@@ -1043,17 +1043,40 @@ export function printArrayLiteral(
   ]);
 }
 
+// When the base is a multi-argument template, its argument list breaks on its
+// own, so keep `is`/`extends` inline instead of breaking the keyword too (#11009).
+function printHeritageClause<T extends Node>(
+  path: AstPath<T>,
+  print: PrettierChildPrint,
+  keyword: string,
+  propertyName: keyof T,
+): Doc {
+  const ref = path.node[propertyName] as Node | undefined;
+  if (!ref) {
+    return "";
+  }
+  const printed = [`${keyword} `, path.call(print, propertyName as any)];
+  if (isMultiArgTemplateReference(ref)) {
+    return [" ", printed];
+  }
+  return group(indent([ifBreak(line, " "), printed]));
+}
+
+function isMultiArgTemplateReference(node: Node): boolean {
+  return (
+    node.kind === SyntaxKind.TypeReference && (node as TypeReferenceNode).arguments.length >= 2
+  );
+}
+
 export function printModelStatement(
   path: AstPath<ModelStatementNode>,
   options: TypeSpecPrettierOptions,
   print: PrettierChildPrint,
 ) {
   const node = path.node;
   const id = path.call(print, "id");
-  const heritage = node.extends
-    ? [ifBreak(line, " "), "extends ", path.call(print, "extends")]
-    : "";
-  const isBase = node.is ? [ifBreak(line, " "), "is ", path.call(print, "is")] : "";
+  const heritage = printHeritageClause(path, print, "extends", "extends");
+  const isBase = printHeritageClause(path, print, "is", "is");
   const generic = printTemplateParameters(path, options, print, "templateParameters");
   const nodeHasComments = hasComments(node, CommentCheckFlags.Dangling);
   const shouldPrintBody = nodeHasComments || !(node.properties.length === 0 && node.is);
@@ -1064,7 +1087,8 @@ export function printModelStatement(
     "model ",
     id,
     generic,
-    group(indent(["", heritage, isBase])),
+    heritage,
+    isBase,
     body,
   ];
 }
@@ -1240,9 +1264,7 @@ function printScalarStatement(
   const id = path.call(print, "id");
   const template = printTemplateParameters(path, options, print, "templateParameters");
 
-  const heritage = node.extends
-    ? [ifBreak(line, " "), "extends ", path.call(print, "extends")]
-    : "";
+  const heritage = printHeritageClause(path, print, "extends", "extends");
   const nodeHasComments = hasComments(node, CommentCheckFlags.Dangling);
   const shouldPrintBody = nodeHasComments || !(node.members.length === 0);
 
@@ -1253,7 +1275,7 @@ function printScalarStatement(
     "scalar ",
     id,
     template,
-    group(indent(["", heritage])),
+    heritage,
     members,
   ];
 }

packages/compiler/test/formatter/formatter.test.ts

@@ -207,6 +207,21 @@ model   Foo extends SuperExtremeAndVeryVeryVeryVeryVeryVeryLongModelThatWillBeTo
           expected: `
 model Foo
   extends SuperExtremeAndVeryVeryVeryVeryVeryVeryLongModelThatWillBeTooLong {}
+`,
+        });
+      });
+
+      it("keeps extends inline and breaks the template arguments when too long", async () => {
+        await assertFormat({
+          code: `
+model Foo extends Base<FirstArgumentTypeName, SecondArgumentTypeName, ThirdArgumentTypeName> {}
+`,
+          expected: `
+model Foo extends Base<
+  FirstArgumentTypeName,
+  SecondArgumentTypeName,
+  ThirdArgumentTypeName
+> {}
 `,
         });
       });
@@ -255,6 +270,21 @@ model   Foo is SuperExtremeAndVeryVeryVeryVeryVeryVeryLongLongLongModelThatWillB
           expected: `
 model Foo
   is SuperExtremeAndVeryVeryVeryVeryVeryVeryLongLongLongModelThatWillBeTooLong;
+`,
+        });
+      });
+
+      it("keeps is inline and breaks the template arguments when too long", async () => {
+        await assertFormat({
+          code: `
+model Foo is Base<FirstArgumentTypeName, SecondArgumentTypeName, ThirdArgumentTypeName>;
+`,
+          expected: `
+model Foo is Base<
+  FirstArgumentTypeName,
+  SecondArgumentTypeName,
+  ThirdArgumentTypeName
+>;
 `,
         });
       });
@@ -809,6 +839,21 @@ scalar Foo extends string;
       });
     });
 
+    it("keeps extends inline and breaks the template arguments when too long", async () => {
+      await assertFormat({
+        code: `
+scalar Foo extends Base<FirstArgumentTypeName, SecondArgumentTypeName, ThirdArgumentTypeName>;
+`,
+        expected: `
+scalar Foo extends Base<
+  FirstArgumentTypeName,
+  SecondArgumentTypeName,
+  ThirdArgumentTypeName
+>;
+`,
+      });
+    });
+
     it("format with template parameters", async () => {
       await assertFormat({
         code: `