@typespec/prettier-plugin-typespec 0.46.0-dev.1 → 0.46.0-dev.2

package/dist/index.js

@@ -4,7 +4,7 @@ var prettier = require('prettier');
 
 //
 // Generated by scripts/regen-nonascii-map.js
-// on node v16.15.0 with unicode 14.0.
+// on node v18.16.0 with unicode 15.0.
 //
 /**
  * @internal
@@ -135,7 +135,7 @@ const nonAsciiIdentifierMap = [
     0xcdd, 0xcde,
     0xce0, 0xce3,
     0xce6, 0xcef,
-    0xcf1, 0xcf2,
+    0xcf1, 0xcf3,
     0xd00, 0xd0c,
     0xd0e, 0xd10,
     0xd12, 0xd44,
@@ -165,7 +165,7 @@ const nonAsciiIdentifierMap = [
     0xea7, 0xebd,
     0xec0, 0xec4,
     0xec6, 0xec6,
-    0xec8, 0xecd,
+    0xec8, 0xece,
     0xed0, 0xed9,
     0xedc, 0xedf,
     0xf00, 0xf47,
@@ -438,7 +438,7 @@ const nonAsciiIdentifierMap = [
     0x10e80, 0x10ea9,
     0x10eab, 0x10ead,
     0x10eb0, 0x10eb1,
-    0x10f00, 0x10f27,
+    0x10efd, 0x10f27,
     0x10f30, 0x10f59,
     0x10f70, 0x10f89,
     0x10fb0, 0x10fcb,
@@ -455,7 +455,7 @@ const nonAsciiIdentifierMap = [
     0x11180, 0x111df,
     0x111e1, 0x111f4,
     0x11200, 0x11211,
-    0x11213, 0x1123e,
+    0x11213, 0x11241,
     0x11280, 0x11286,
     0x11288, 0x11288,
     0x1128a, 0x1128d,
@@ -508,6 +508,7 @@ const nonAsciiIdentifierMap = [
     0x11a00, 0x11a47,
     0x11a50, 0x11aa2,
     0x11ab0, 0x11af8,
+    0x11b00, 0x11b09,
     0x11c00, 0x11c08,
     0x11c0a, 0x11c36,
     0x11c38, 0x11c45,
@@ -529,6 +530,9 @@ const nonAsciiIdentifierMap = [
     0x11d93, 0x11d98,
     0x11da0, 0x11da9,
     0x11ee0, 0x11ef8,
+    0x11f00, 0x11f10,
+    0x11f12, 0x11f3a,
+    0x11f3e, 0x11f59,
     0x11fb0, 0x11fb0,
     0x11fc0, 0x11ff1,
     0x11fff, 0x12399,
@@ -536,8 +540,7 @@ const nonAsciiIdentifierMap = [
     0x12470, 0x12474,
     0x12480, 0x12543,
     0x12f90, 0x12ff2,
-    0x13000, 0x1342e,
-    0x13430, 0x13438,
+    0x13000, 0x13455,
     0x14400, 0x14646,
     0x16800, 0x16a38,
     0x16a40, 0x16a5e,
@@ -564,7 +567,9 @@ const nonAsciiIdentifierMap = [
     0x1aff5, 0x1affb,
     0x1affd, 0x1affe,
     0x1b000, 0x1b122,
+    0x1b132, 0x1b132,
     0x1b150, 0x1b152,
+    0x1b155, 0x1b155,
     0x1b164, 0x1b167,
     0x1b170, 0x1b2fb,
     0x1bc00, 0x1bc6a,
@@ -579,6 +584,7 @@ const nonAsciiIdentifierMap = [
     0x1d100, 0x1d126,
     0x1d129, 0x1d1ea,
     0x1d200, 0x1d245,
+    0x1d2c0, 0x1d2d3,
     0x1d2e0, 0x1d2f3,
     0x1d300, 0x1d356,
     0x1d360, 0x1d378,
@@ -606,11 +612,14 @@ const nonAsciiIdentifierMap = [
     0x1da9b, 0x1da9f,
     0x1daa1, 0x1daaf,
     0x1df00, 0x1df1e,
+    0x1df25, 0x1df2a,
     0x1e000, 0x1e006,
     0x1e008, 0x1e018,
     0x1e01b, 0x1e021,
     0x1e023, 0x1e024,
     0x1e026, 0x1e02a,
+    0x1e030, 0x1e06d,
+    0x1e08f, 0x1e08f,
     0x1e100, 0x1e12c,
     0x1e130, 0x1e13d,
     0x1e140, 0x1e149,
@@ -618,6 +627,7 @@ const nonAsciiIdentifierMap = [
     0x1e290, 0x1e2ae,
     0x1e2c0, 0x1e2f9,
     0x1e2ff, 0x1e2ff,
+    0x1e4d0, 0x1e4f9,
     0x1e7e0, 0x1e7e6,
     0x1e7e8, 0x1e7eb,
     0x1e7ed, 0x1e7ee,
@@ -676,10 +686,10 @@ const nonAsciiIdentifierMap = [
     0x1f250, 0x1f251,
     0x1f260, 0x1f265,
     0x1f300, 0x1f6d7,
-    0x1f6dd, 0x1f6ec,
+    0x1f6dc, 0x1f6ec,
     0x1f6f0, 0x1f6fc,
-    0x1f700, 0x1f773,
-    0x1f780, 0x1f7d8,
+    0x1f700, 0x1f776,
+    0x1f77b, 0x1f7d9,
     0x1f7e0, 0x1f7eb,
     0x1f7f0, 0x1f7f0,
     0x1f800, 0x1f80b,
@@ -690,25 +700,24 @@ const nonAsciiIdentifierMap = [
     0x1f8b0, 0x1f8b1,
     0x1f900, 0x1fa53,
     0x1fa60, 0x1fa6d,
-    0x1fa70, 0x1fa74,
-    0x1fa78, 0x1fa7c,
-    0x1fa80, 0x1fa86,
-    0x1fa90, 0x1faac,
-    0x1fab0, 0x1faba,
-    0x1fac0, 0x1fac5,
-    0x1fad0, 0x1fad9,
-    0x1fae0, 0x1fae7,
-    0x1faf0, 0x1faf6,
+    0x1fa70, 0x1fa7c,
+    0x1fa80, 0x1fa88,
+    0x1fa90, 0x1fabd,
+    0x1fabf, 0x1fac5,
+    0x1face, 0x1fadb,
+    0x1fae0, 0x1fae8,
+    0x1faf0, 0x1faf8,
     0x1fb00, 0x1fb92,
     0x1fb94, 0x1fbca,
     0x1fbf0, 0x1fbf9,
     0x20000, 0x2a6df,
-    0x2a700, 0x2b738,
+    0x2a700, 0x2b739,
     0x2b740, 0x2b81d,
     0x2b820, 0x2cea1,
     0x2ceb0, 0x2ebe0,
     0x2f800, 0x2fa1d,
     0x30000, 0x3134a,
+    0x31350, 0x323af,
     0xe0001, 0xe0001,
     0xe0020, 0xe007f,
     0xe0100, 0xe01ef,
@@ -2885,41 +2894,17 @@ function getTokenDisplayTable(entries) {
     return table;
 }
 
-(this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-(this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-/**
- * A specially typed version of `Array.isArray` to work around [this issue](https://github.com/microsoft/TypeScript/issues/17002).
- */
-function isArray(
-// eslint-disable-next-line @typescript-eslint/ban-types
-arg) {
-    return Array.isArray(arg);
-}
-/**
- * Casts away readonly typing.
- *
- * Use it like this when it is safe to override readonly typing:
- *   mutate(item).prop = value;
- */
-function mutate(value) {
-    return value;
-}
-
 const { util } = prettier;
 /**
  * Override the default behavior to attach comments to syntax node.
  */
 const commentHandler = {
-    ownLine: (comment) => [addEmptyInterfaceComment, addEmptyModelComment, addStatementDecoratorComment].some((x) => x(comment)),
+    ownLine: (comment, text, options, ast, isLastComment) => [
+        addEmptyInterfaceComment,
+        addEmptyModelComment,
+        addStatementDecoratorComment,
+        handleOnlyComments,
+    ].some((x) => x({ comment, text, options, ast: ast, isLastComment })),
 };
 /**
  * When a comment is on an empty interface make sure it gets added as a dangling comment on it and not on the identifier.
@@ -2930,7 +2915,7 @@ const commentHandler = {
  *   // My comment
  * }
  */
-function addEmptyInterfaceComment(comment) {
+function addEmptyInterfaceComment({ comment }) {
     const { precedingNode, enclosingNode } = comment;
     if (enclosingNode &&
         enclosingNode.kind === SyntaxKind.InterfaceStatement &&
@@ -2953,7 +2938,7 @@ function addEmptyInterfaceComment(comment) {
  * model Foo {
  * }
  */
-function addStatementDecoratorComment(comment) {
+function addStatementDecoratorComment({ comment }) {
     const { enclosingNode, precedingNode } = comment;
     if (precedingNode &&
         precedingNode.kind === SyntaxKind.DecoratorExpression &&
@@ -2979,7 +2964,7 @@ function addStatementDecoratorComment(comment) {
  *   // My comment
  * }
  */
-function addEmptyModelComment(comment) {
+function addEmptyModelComment({ comment }) {
     const { precedingNode, enclosingNode } = comment;
     if (enclosingNode &&
         enclosingNode.kind === SyntaxKind.ModelStatement &&
@@ -2993,6 +2978,31 @@ function addEmptyModelComment(comment) {
     }
     return false;
 }
+function handleOnlyComments({ comment, ast, isLastComment }) {
+    var _a, _b;
+    const { enclosingNode } = comment;
+    if (((_a = ast === null || ast === void 0 ? void 0 : ast.statements) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+        if (isLastComment) {
+            util.addDanglingComment(ast, comment, undefined);
+        }
+        else {
+            util.addLeadingComment(ast, comment);
+        }
+        return true;
+    }
+    if ((enclosingNode === null || enclosingNode === void 0 ? void 0 : enclosingNode.kind) === SyntaxKind.TypeSpecScript &&
+        enclosingNode.statements.length === 0 &&
+        ((_b = enclosingNode.directives) === null || _b === void 0 ? void 0 : _b.length) === 0) {
+        if (isLastComment) {
+            util.addDanglingComment(enclosingNode, comment, undefined);
+        }
+        else {
+            util.addLeadingComment(enclosingNode, comment);
+        }
+        return true;
+    }
+    return false;
+}
 
 /**
  * Check if the current path should be wrapped in parentheses
@@ -3056,9 +3066,7 @@ path, options, print) {
     switch (node.kind) {
         // Root
         case SyntaxKind.TypeSpecScript:
-            return [
-                printStatementSequence(path, options, print, "statements"),
-            ];
+            return printTypeSpecScript(path, options, print);
         // Statements
         case SyntaxKind.ImportStatement:
             return [`import "${node.path.value}";`];
@@ -3205,14 +3213,25 @@ path, options, print) {
             // https://github.com/microsoft/typespec/issues/1319 Tracks pretty-printing doc comments.
             compilerAssert(false, "Currently, doc comments are only handled as regular comments and we do not opt in to parsing them so we shouldn't reach here.");
             return "";
-        case SyntaxKind.JsSourceFile:
         case SyntaxKind.EmptyStatement:
+            return "";
+        case SyntaxKind.JsSourceFile:
         case SyntaxKind.InvalidStatement:
             return getRawText(node, options);
         default:
             return getRawText(node, options);
     }
 }
+function printTypeSpecScript(path, options, print) {
+    const node = path.getValue();
+    const nodeHasComments = hasComments(node, CommentCheckFlags.Dangling);
+    const body = [];
+    if (nodeHasComments) {
+        body.push(printDanglingComments(path, options, { sameIndent: true }));
+    }
+    body.push(printStatementSequence(path, options, print, "statements"));
+    return body;
+}
 function printAliasStatement(path, options, print) {
     const id = path.call(print, "id");
     const template = printTemplateParameters(path, options, print, "templateParameters");
@@ -3238,6 +3257,7 @@ function canAttachComment(node) {
     return Boolean(kind &&
         kind !== SyntaxKind.LineComment &&
         kind !== SyntaxKind.BlockComment &&
+        kind !== SyntaxKind.EmptyStatement &&
         !(node.flags & 8 /* NodeFlags.Synthetic */));
 }
 function printComment(commentPath, options) {
@@ -3697,26 +3717,18 @@ function printScalarStatement(path, options, print) {
     ];
 }
 function printNamespaceStatement(path, options, print) {
-    const printNested = (currentPath, parentNames) => {
-        var _a;
-        const names = [...parentNames, currentPath.call(print, "id")];
-        const currentNode = currentPath.getNode();
-        if (!isArray(currentNode === null || currentNode === void 0 ? void 0 : currentNode.statements) &&
-            ((_a = currentNode === null || currentNode === void 0 ? void 0 : currentNode.statements) === null || _a === void 0 ? void 0 : _a.kind) === SyntaxKind.NamespaceStatement) {
-            return path.call((x) => printNested(x, names), "statements");
-        }
-        const suffix = (currentNode === null || currentNode === void 0 ? void 0 : currentNode.statements) === undefined
-            ? ";"
-            : [
-                " {",
-                indent([hardline, printStatementSequence(path, options, print, "statements")]),
-                hardline,
-                "}",
-            ];
-        const { decorators } = printDecorators(path, options, print, { tryInline: false });
-        return [decorators, `namespace `, join(".", names), suffix];
-    };
-    return printNested(path, []);
+    const names = path.map(print, "ids");
+    const currentNode = path.getNode();
+    const suffix = (currentNode === null || currentNode === void 0 ? void 0 : currentNode.statements) === undefined
+        ? ";"
+        : [
+            " {",
+            indent([hardline, printStatementSequence(path, options, print, "statements")]),
+            hardline,
+            "}",
+        ];
+    const { decorators } = printDecorators(path, options, print, { tryInline: false });
+    return [decorators, `namespace `, join(".", names), suffix];
 }
 function printOperationSignatureDeclaration(path, options, print) {
     return ["(", path.call(print, "parameters"), "): ", path.call(print, "returnType")];
@@ -4049,6 +4061,35 @@ function isLineComment(comment) {
     return comment.kind === SyntaxKind.BlockComment;
 }
 
+(this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+(this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+/**
+ * A specially typed version of `Array.isArray` to work around [this issue](https://github.com/microsoft/TypeScript/issues/17002).
+ */
+function isArray(
+// eslint-disable-next-line @typescript-eslint/ban-types
+arg) {
+    return Array.isArray(arg);
+}
+/**
+ * Casts away readonly typing.
+ *
+ * Use it like this when it is safe to override readonly typing:
+ *   mutate(item).prop = value;
+ */
+function mutate(value) {
+    return value;
+}
+
 /**
  * The fixed set of options for each of the kinds of delimited lists in TypeSpec.
  */
@@ -6339,6 +6380,213 @@ function createParser(code, options = {}) {
             : undefined;
     }
 }
+function visitChildren(node, cb) {
+    if (node.directives) {
+        const result = visitEach(cb, node.directives);
+        if (result)
+            return result;
+    }
+    if (node.docs) {
+        const result = visitEach(cb, node.docs);
+        if (result)
+            return result;
+    }
+    switch (node.kind) {
+        case SyntaxKind.TypeSpecScript:
+            return visitNode(cb, node.id) || visitEach(cb, node.statements);
+        case SyntaxKind.ArrayExpression:
+            return visitNode(cb, node.elementType);
+        case SyntaxKind.AugmentDecoratorStatement:
+            return (visitNode(cb, node.target) ||
+                visitNode(cb, node.targetType) ||
+                visitEach(cb, node.arguments));
+        case SyntaxKind.DecoratorExpression:
+            return visitNode(cb, node.target) || visitEach(cb, node.arguments);
+        case SyntaxKind.DirectiveExpression:
+            return visitNode(cb, node.target) || visitEach(cb, node.arguments);
+        case SyntaxKind.ImportStatement:
+            return visitNode(cb, node.path);
+        case SyntaxKind.OperationStatement:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.templateParameters) ||
+                visitNode(cb, node.signature));
+        case SyntaxKind.OperationSignatureDeclaration:
+            return visitNode(cb, node.parameters) || visitNode(cb, node.returnType);
+        case SyntaxKind.OperationSignatureReference:
+            return visitNode(cb, node.baseOperation);
+        case SyntaxKind.NamespaceStatement:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                (isArray(node.statements) ? visitEach(cb, node.statements) : visitNode(cb, node.statements)));
+        case SyntaxKind.InterfaceStatement:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.templateParameters) ||
+                visitEach(cb, node.extends) ||
+                visitEach(cb, node.operations));
+        case SyntaxKind.UsingStatement:
+            return visitNode(cb, node.name);
+        case SyntaxKind.IntersectionExpression:
+            return visitEach(cb, node.options);
+        case SyntaxKind.MemberExpression:
+            return visitNode(cb, node.base) || visitNode(cb, node.id);
+        case SyntaxKind.ModelExpression:
+            return visitEach(cb, node.properties);
+        case SyntaxKind.ModelProperty:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitNode(cb, node.value) ||
+                visitNode(cb, node.default));
+        case SyntaxKind.ModelSpreadProperty:
+            return visitNode(cb, node.target);
+        case SyntaxKind.ModelStatement:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.templateParameters) ||
+                visitNode(cb, node.extends) ||
+                visitNode(cb, node.is) ||
+                visitEach(cb, node.properties));
+        case SyntaxKind.ScalarStatement:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.templateParameters) ||
+                visitNode(cb, node.extends));
+        case SyntaxKind.UnionStatement:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.templateParameters) ||
+                visitEach(cb, node.options));
+        case SyntaxKind.UnionVariant:
+            return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitNode(cb, node.value);
+        case SyntaxKind.EnumStatement:
+            return (visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.members));
+        case SyntaxKind.EnumMember:
+            return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitNode(cb, node.value);
+        case SyntaxKind.EnumSpreadMember:
+            return visitNode(cb, node.target);
+        case SyntaxKind.AliasStatement:
+            return (visitNode(cb, node.id) ||
+                visitEach(cb, node.templateParameters) ||
+                visitNode(cb, node.value));
+        case SyntaxKind.DecoratorDeclarationStatement:
+            return (visitEach(cb, node.modifiers) ||
+                visitNode(cb, node.id) ||
+                visitNode(cb, node.target) ||
+                visitEach(cb, node.parameters));
+        case SyntaxKind.FunctionDeclarationStatement:
+            return (visitEach(cb, node.modifiers) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.parameters) ||
+                visitNode(cb, node.returnType));
+        case SyntaxKind.FunctionParameter:
+            return visitNode(cb, node.id) || visitNode(cb, node.type);
+        case SyntaxKind.TypeReference:
+            return visitNode(cb, node.target) || visitEach(cb, node.arguments);
+        case SyntaxKind.ValueOfExpression:
+            return visitNode(cb, node.target);
+        case SyntaxKind.TupleExpression:
+            return visitEach(cb, node.values);
+        case SyntaxKind.UnionExpression:
+            return visitEach(cb, node.options);
+        case SyntaxKind.Projection:
+            return (visitNode(cb, node.directionId) ||
+                visitEach(cb, node.modifierIds) ||
+                visitEach(cb, node.parameters) ||
+                visitEach(cb, node.body));
+        case SyntaxKind.ProjectionExpressionStatement:
+            return visitNode(cb, node.expr);
+        case SyntaxKind.ProjectionCallExpression:
+            return visitNode(cb, node.target) || visitEach(cb, node.arguments);
+        case SyntaxKind.ProjectionMemberExpression:
+            return visitNode(cb, node.base) || visitNode(cb, node.id);
+        // binops
+        case SyntaxKind.ProjectionLogicalExpression:
+        case SyntaxKind.ProjectionRelationalExpression:
+        case SyntaxKind.ProjectionArithmeticExpression:
+        case SyntaxKind.ProjectionEqualityExpression:
+            return visitNode(cb, node.left) || visitNode(cb, node.right);
+        case SyntaxKind.ProjectionUnaryExpression:
+            return visitNode(cb, node.target);
+        case SyntaxKind.ProjectionModelExpression:
+            return visitEach(cb, node.properties);
+        case SyntaxKind.ProjectionModelProperty:
+            return (visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitNode(cb, node.value) ||
+                visitNode(cb, node.default));
+        case SyntaxKind.ProjectionModelSpreadProperty:
+            return visitNode(cb, node.target);
+        case SyntaxKind.ProjectionTupleExpression:
+            return visitEach(cb, node.values);
+        case SyntaxKind.ProjectionBlockExpression:
+            return visitEach(cb, node.statements);
+        case SyntaxKind.ProjectionIfExpression:
+            return (visitNode(cb, node.test) || visitNode(cb, node.consequent) || visitNode(cb, node.alternate));
+        case SyntaxKind.ProjectionLambdaExpression:
+            return visitEach(cb, node.parameters) || visitNode(cb, node.body);
+        case SyntaxKind.ProjectionStatement:
+            return (visitNode(cb, node.id) || visitNode(cb, node.selector) || visitEach(cb, node.projections));
+        case SyntaxKind.ProjectionDecoratorReferenceExpression:
+            return visitNode(cb, node.target);
+        case SyntaxKind.Return:
+            return visitNode(cb, node.value);
+        case SyntaxKind.InvalidStatement:
+            return visitEach(cb, node.decorators);
+        case SyntaxKind.TemplateParameterDeclaration:
+            return (visitNode(cb, node.id) || visitNode(cb, node.constraint) || visitNode(cb, node.default));
+        case SyntaxKind.ProjectionLambdaParameterDeclaration:
+            return visitNode(cb, node.id);
+        case SyntaxKind.ProjectionParameterDeclaration:
+            return visitNode(cb, node.id);
+        case SyntaxKind.Doc:
+            return visitEach(cb, node.content) || visitEach(cb, node.tags);
+        case SyntaxKind.DocParamTag:
+        case SyntaxKind.DocTemplateTag:
+            return (visitNode(cb, node.tagName) || visitNode(cb, node.paramName) || visitEach(cb, node.content));
+        case SyntaxKind.DocReturnsTag:
+        case SyntaxKind.DocUnknownTag:
+            return visitNode(cb, node.tagName) || visitEach(cb, node.content);
+        // no children for the rest of these.
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NumericLiteral:
+        case SyntaxKind.BooleanLiteral:
+        case SyntaxKind.Identifier:
+        case SyntaxKind.EmptyStatement:
+        case SyntaxKind.ProjectionModelSelector:
+        case SyntaxKind.ProjectionModelPropertySelector:
+        case SyntaxKind.ProjectionUnionSelector:
+        case SyntaxKind.ProjectionUnionVariantSelector:
+        case SyntaxKind.ProjectionInterfaceSelector:
+        case SyntaxKind.ProjectionOperationSelector:
+        case SyntaxKind.ProjectionEnumSelector:
+        case SyntaxKind.ProjectionEnumMemberSelector:
+        case SyntaxKind.VoidKeyword:
+        case SyntaxKind.NeverKeyword:
+        case SyntaxKind.ExternKeyword:
+        case SyntaxKind.UnknownKeyword:
+        case SyntaxKind.JsSourceFile:
+        case SyntaxKind.DocText:
+            return;
+        default:
+            return;
+    }
+}
+function visitNode(cb, node) {
+    return node && cb(node);
+}
+function visitEach(cb, nodes) {
+    if (!nodes) {
+        return;
+    }
+    for (const node of nodes) {
+        const result = cb(node);
+        if (result) {
+            return result;
+        }
+    }
+    return;
+}
 function isBlocklessNamespace(node) {
     if (node.kind !== SyntaxKind.NamespaceStatement) {
         return false;
@@ -6351,12 +6599,34 @@ function isBlocklessNamespace(node) {
 
 function parse(text, parsers, opts) {
     const result = parse$1(text, { comments: true, docs: false });
+    flattenNamespaces(result);
     const errors = result.parseDiagnostics.filter((x) => x.severity === "error");
     if (errors.length > 0 && !result.printable) {
         throw new PrettierParserError(errors[0]);
     }
     return result;
 }
+/**
+ * We are patching the syntax tree to flatten the namespace nodes that are created from namespace Foo.Bar; which have the same pos, end
+ * This causes prettier to not know where comments belong.
+ * https://github.com/microsoft/typespec/pull/2061
+ */
+function flattenNamespaces(base) {
+    visitChildren(base, (node) => {
+        if (node.kind === SyntaxKind.NamespaceStatement) {
+            let current = node;
+            const ids = [node.id];
+            while (current.statements && "kind" in current.statements) {
+                current = current.statements;
+                ids.push(current.id);
+            }
+            Object.assign(node, current, {
+                ids,
+            });
+            flattenNamespaces(current);
+        }
+    });
+}
 class PrettierParserError extends Error {
     constructor(error) {
         var _a, _b;