Update to support prettier 3.0

packages/compiler/package.json

@@ -79,7 +79,7 @@
     "globby": "~13.1.1",
     "js-yaml": "~4.1.0",
     "mustache": "~4.2.0",
-    "prettier": "~2.8.7",
+    "prettier": "~3.0.0",
     "prompts": "~2.4.1",
     "vscode-languageserver": "~8.1.0",
     "vscode-languageserver-textdocument": "~1.0.1",

packages/compiler/src/core/formatter-fs.ts

@@ -66,7 +66,7 @@ export async function findUnformattedTypeSpecFiles(
 export async function formatTypeSpecFile(filename: string) {
   const content = await readFile(filename, "utf-8");
   const prettierConfig = await prettier.resolveConfig(filename);
-  const formattedContent = formatTypeSpec(content, prettierConfig ?? {});
+  const formattedContent = await formatTypeSpec(content, prettierConfig ?? {});
   await writeFile(filename, formattedContent);
 }
 

packages/compiler/src/core/formatter.ts

@@ -2,8 +2,8 @@ import prettier from "prettier";
 import * as typespecPrettierPlugin from "../formatter/index.js";
 export { printId as formatIdentifier } from "../formatter/print/printer.js";
 
-export function formatTypeSpec(code: string, prettierConfig?: prettier.Options): string {
-  const output = prettier.format(code, {
+export async function formatTypeSpec(code: string, prettierConfig?: prettier.Options): Promise<string> {
+  const output = await prettier.format(code, {
     ...prettierConfig,
     parser: "typespec",
     plugins: [typespecPrettierPlugin],

packages/compiler/src/formatter/parser.ts

@@ -1,13 +1,11 @@
-import { Parser, ParserOptions } from "prettier";
+import { ParserOptions } from "prettier";
 import { getSourceLocation } from "../core/diagnostics.js";
 import { parse as typespecParse, visitChildren } from "../core/parser.js";
 import { Diagnostic, Node, SyntaxKind, TypeSpecScriptNode } from "../core/types.js";
 import { mutate } from "../core/util.js";
 
 export function parse(
-  text: string,
-  parsers: { [parserName: string]: Parser },
-  opts: ParserOptions & { parentParser?: string }
+  text: string, options: ParserOptions<any>,
 ): TypeSpecScriptNode {
   const result = typespecParse(text, { comments: true, docs: true });
 

packages/compiler/src/formatter/print/prettier-ast-path.ts

@@ -0,0 +1,86 @@
+// --------------------------------------------------
+//  Unfortunately have to make our own `AstPath` as prettier types have issue with readonly Array.
+// --------------------------------------------------
+export type AST = any;
+
+// The type of elements that make up the given array T.
+type ArrayElement<T> = T extends Array<infer E> ? E : never;
+
+
+// Effectively performing T[P], except that it's telling TypeScript that it's
+// safe to do this for tuples, arrays, or objects.
+type IndexValue<T, P> = T extends readonly any[]
+  ? P extends number
+    ? T[P]
+    : never
+  : P extends keyof T
+  ? T[P]
+  : never;
+
+
+type CallProperties<T> = keyof T;
+type IterProperties<T> = keyof T;
+
+type CallCallback<T, U> = (path: AstPath<T>, index: number, value: any) => U;
+type EachCallback<T> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => void;
+type MapCallback<T, U> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => U;
+
+// https://github.com/prettier/prettier/blob/next/src/common/ast-path.js
+export interface AstPath<T = any> {
+  get key(): string | null;
+  get index(): number | null;
+  get node(): T;
+  get parent(): T | null;
+  get grandparent(): T | null;
+  get isInArray(): boolean;
+  get siblings(): T[] | null;
+  get next(): T | null;
+  get previous(): T | null;
+  get isFirst(): boolean;
+  get isLast(): boolean;
+  get isRoot(): boolean;
+  get root(): T;
+  get ancestors(): T[];
+
+  stack: T[];
+
+  callParent<U>(callback: (path: this) => U, count?: number): U;
+
+  /**
+   * @deprecated Please use `AstPath#key` or `AstPath#index`
+   */
+  getName(): PropertyKey | null;
+
+  /**
+   * @deprecated Please use `AstPath#node` or  `AstPath#siblings`
+   */
+  getValue(): T;
+
+  getNode(count?: number): T | null;
+
+  getParentNode(count?: number): T | null;
+
+  match(
+    ...predicates: Array<(node: any, name: string | null, number: number | null) => boolean>
+  ): boolean;
+
+  // For each of the tree walk functions (call, each, and map) this provides 5
+  // strict type signatures, along with a fallback at the end if you end up
+  // calling more than 5 properties deep. This helps a lot with typing because
+  // for the majority of cases you're calling fewer than 5 properties, so the
+  // tree walk functions have a clearer understanding of what you're doing.
+  //
+  // Note that resolving these types is somewhat complicated, and it wasn't
+  // even supported until TypeScript 4.2 (before it would just say that the
+  // type instantiation was excessively deep and possibly infinite).
+
+  call<U>(callback: CallCallback<T, U>): U;
+  call<U, P1 extends CallProperties<T>>(callback: CallCallback<IndexValue<T, P1>, U>, prop1: P1): U;
+
+  each(callback: EachCallback<T>): void;
+  each<P1 extends IterProperties<T>>(callback: EachCallback<IndexValue<T, P1>>, prop1: P1): void;
+
+
+  map<U>(callback: MapCallback<T, U>): U[];
+  map<U, P1 extends IterProperties<T>>(callback: MapCallback<IndexValue<T, P1>, U>, prop1: P1): U[];
+}

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

@@ -1,4 +1,6 @@
-import prettier, { AstPath, Doc, Printer } from "prettier";
+//  TODO revisit `getValue` is deprecated.
+/* eslint-disable deprecation/deprecation */
+import prettier, { Doc, Printer } from "prettier";
 import { isIdentifierContinue, isIdentifierStart, utf16CodeUnits } from "../../core/charcode.js";
 import { compilerAssert } from "../../core/diagnostics.js";
 import { Keywords } from "../../core/scanner.js";
@@ -13,8 +15,10 @@ import {
   DecoratorExpressionNode,
   DirectiveExpressionNode,
   DocNode,
+  ProjectionDecoratorReferenceExpressionNode,
   EnumMemberNode,
   EnumSpreadMemberNode,
+  UsingStatementNode,
   EnumStatementNode,
   FunctionDeclarationStatementNode,
   FunctionParameterNode,
@@ -70,12 +74,13 @@ import {
 import { FlattenedNamespaceStatementNode } from "../types.js";
 import { commentHandler } from "./comment-handler.js";
 import { needsParens } from "./needs-parens.js";
+import { AstPath } from "./prettier-ast-path.js";
 import { DecorableNode, PrettierChildPrint, TypeSpecPrettierOptions } from "./types.js";
 
 const { align, breakParent, group, hardline, ifBreak, indent, join, line, softline } =
   prettier.doc.builders;
 
-const { isNextLineEmpty } = prettier.util;
+const { isNextLineEmpty } = prettier.util as any;
 
 /**
  * If the decorators for that node should try to be kept inline.
@@ -135,7 +140,7 @@ export function printNode(
     case SyntaxKind.ImportStatement:
       return [`import "${node.path.value}";`];
     case SyntaxKind.UsingStatement:
-      return [`using `, path.call(print, "name"), `;`];
+      return [`using `, (path as AstPath<UsingStatementNode>).call(print, "name"), `;`];
     case SyntaxKind.OperationStatement:
       return printOperationStatement(path as AstPath<OperationStatementNode>, options, print);
     case SyntaxKind.OperationSignatureDeclaration:
@@ -333,7 +338,7 @@ export function printNode(
     case SyntaxKind.ProjectionTupleExpression:
       return printTuple(path as AstPath<ProjectionTupleExpressionNode>, options, print);
     case SyntaxKind.ProjectionDecoratorReferenceExpression:
-      return path.call(print, "target");
+      return (path as AstPath<ProjectionDecoratorReferenceExpressionNode>).call(print, "target");
     case SyntaxKind.Return:
       return printReturnExpression(path as AstPath<ReturnExpressionNode>, options, print);
     case SyntaxKind.Doc:
@@ -401,9 +406,9 @@ function printTemplateParameters<T extends Node>(
 
   const shouldHug = (args as any).length === 1;
   if (shouldHug) {
-    return ["<", join(", ", path.map(print, propertyName)), ">"];
+    return ["<", join(", ", path.map(print, propertyName as any)), ">"];
   } else {
-    const body = indent([softline, join([", ", softline], path.map(print, propertyName))]);
+    const body = indent([softline, join([", ", softline], path.map(print, propertyName as any))]);
     return group(["<", body, softline, ">"]);
   }
 }
@@ -855,7 +860,7 @@ function printDanglingComments(
     return "";
   }
   path.each((commentPath) => {
-    const comment = commentPath.getValue();
+    const comment: any = commentPath.getValue();
     if (!comment.leading && !comment.trailing) {
       parts.push(printComment(path, options));
     }
@@ -1289,7 +1294,7 @@ export function printStatementSequence<T extends Node>(
         parts.push(hardline);
       }
     }
-  }, property);
+  }, property as any);
 
   return parts;
 }
@@ -1558,7 +1563,7 @@ function printProjectionExpressionStatements<T extends Node>(
         parts.push(hardline);
       }
     }
-  }, key);
+  }, key as any);
   return parts;
 }
 
@@ -1689,7 +1694,7 @@ function printItemList<T extends Node>(
   print: PrettierChildPrint,
   key: keyof T
 ) {
-  return join(", ", path.map(print, key));
+  return join(", ", path.map(print, key as any));
 }
 
 /**

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

@@ -1,9 +1,10 @@
-import { AstPath, Doc, ParserOptions } from "prettier";
-import { DecoratorExpressionNode, Node } from "../../core/types.js";
+import { Doc, ParserOptions } from "prettier";
+import { DecoratorExpressionNode } from "../../core/types.js";
 
 export interface TypeSpecPrettierOptions extends ParserOptions {}
 
-export type PrettierChildPrint = (path: AstPath<Node>, index?: number) => Doc;
+// export type PrettierChildPrint = (path: AstPath<Node>, index?: number) => Doc;
+export type PrettierChildPrint = (...args: any) => Doc;
 
 export interface DecorableNode {
   decorators: readonly DecoratorExpressionNode[];

packages/compiler/src/init/init.ts

@@ -331,7 +331,7 @@ async function writeMain(host: CompilerHost, config: ScaffoldingConfig) {
   const lines = [...config.libraries.map((x) => `import "${x}";`), ""];
   const content = lines.join("\n");
 
-  return host.writeFile(joinPaths(config.directory, "main.tsp"), formatTypeSpec(content));
+  return host.writeFile(joinPaths(config.directory, "main.tsp"), await formatTypeSpec(content));
 }
 
 async function writeFiles(host: CompilerHost, config: ScaffoldingConfig) {