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

package/dist/index.js

@@ -1542,6 +1542,33 @@ const diagnostics = {
             default: paramMessage `Emitter '${"emitterName"}' requires '${"requiredImport"}' to be imported. Add 'import "${"requiredImport"}".`,
         },
     },
+    /**
+     * Linter
+     */
+    "invalid-rule-ref": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Reference "${"ref"}" is not a valid reference to a rule or ruleset. It must be in the following format: "<library-name>:<rule-name>"`,
+        },
+    },
+    "unknown-rule": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Rule "${"ruleName"}" is not found in library "${"libraryName"}"`,
+        },
+    },
+    "unknown-rule-set": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Rule set "${"ruleSetName"}" is not found in library "${"libraryName"}"`,
+        },
+    },
+    "rule-enabled-disabled": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Rule "${"ruleName"}" has been enabled and disabled in the same ruleset.`,
+        },
+    },
     /**
      * Decorator
      */
@@ -2947,6 +2974,8 @@ function addStatementDecoratorComment({ comment }) {
             enclosingNode.kind === SyntaxKind.ModelStatement ||
             enclosingNode.kind === SyntaxKind.EnumStatement ||
             enclosingNode.kind === SyntaxKind.OperationStatement ||
+            enclosingNode.kind === SyntaxKind.ScalarStatement ||
+            enclosingNode.kind === SyntaxKind.InterfaceStatement ||
             enclosingNode.kind === SyntaxKind.ModelProperty ||
             enclosingNode.kind === SyntaxKind.EnumMember ||
             enclosingNode.kind === SyntaxKind.UnionStatement)) {
@@ -3032,6 +3061,14 @@ function needsParens(path, options) {
 
 const { align, breakParent, group, hardline, ifBreak, indent, join, line, softline } = prettier.doc.builders;
 const { isNextLineEmpty } = prettier.util;
+/**
+ * If the decorators for that node should try to be kept inline.
+ */
+const DecoratorsTryInline = {
+    modelProperty: true,
+    enumMember: true,
+    unionVariant: true,
+};
 const typespecPrinter = {
     print: printTypeSpec,
     canAttachComment: canAttachComment,
@@ -3042,10 +3079,11 @@ function printTypeSpec(
 // Path to the AST node to print
 path, options, print) {
     const node = path.getValue();
+    const docs = printDocComments(path, options, print);
     const directives = shouldPrintDirective(node) ? printDirectives(path, options, print) : "";
     const printedNode = printNode(path, options, print);
     const value = needsParens(path) ? ["(", printedNode, ")"] : printedNode;
-    const parts = [directives, value];
+    const parts = [docs, directives, value];
     if (node.kind === SyntaxKind.TypeSpecScript) {
         // For TypeSpecScript(root of typespec document) we had a new line at the end.
         // This must be done here so the hardline entry can be the last item of the doc array returned by the printer
@@ -3062,7 +3100,6 @@ function printNode(
 // Path to the AST node to print
 path, options, print) {
     const node = path.getValue();
-    printDirectives(path, options, print);
     switch (node.kind) {
         // Root
         case SyntaxKind.TypeSpecScript:
@@ -3205,6 +3242,7 @@ path, options, print) {
         case SyntaxKind.Return:
             return printReturnExpression(path, options, print);
         case SyntaxKind.Doc:
+            return printDoc(path, options);
         case SyntaxKind.DocText:
         case SyntaxKind.DocParamTag:
         case SyntaxKind.DocTemplateTag:
@@ -3258,6 +3296,12 @@ function canAttachComment(node) {
         kind !== SyntaxKind.LineComment &&
         kind !== SyntaxKind.BlockComment &&
         kind !== SyntaxKind.EmptyStatement &&
+        kind !== SyntaxKind.Doc &&
+        kind !== SyntaxKind.DocParamTag &&
+        kind !== SyntaxKind.DocReturnsTag &&
+        kind !== SyntaxKind.DocTemplateTag &&
+        kind !== SyntaxKind.DocText &&
+        kind !== SyntaxKind.DocUnknownTag &&
         !(node.flags & 8 /* NodeFlags.Synthetic */));
 }
 function printComment(commentPath, options) {
@@ -3275,11 +3319,10 @@ function printComment(commentPath, options) {
 function printBlockComment(commentPath, options) {
     const comment = commentPath.getValue();
     const rawComment = options.originalText.slice(comment.pos + 2, comment.end - 2);
-    if (isIndentableBlockComment(rawComment)) {
-        const printed = printIndentableBlockComment(rawComment);
-        return printed;
-    }
-    return ["/*", rawComment, "*/"];
+    const printed = isIndentableBlockComment(rawComment)
+        ? printIndentableBlockCommentContent(rawComment)
+        : rawComment;
+    return ["/*", printed, "*/"];
 }
 function isIndentableBlockComment(rawComment) {
     // If the comment has multiple lines and every line starts with a star
@@ -3289,28 +3332,42 @@ function isIndentableBlockComment(rawComment) {
     const lines = `*${rawComment}*`.split("\n");
     return lines.length > 1 && lines.every((line) => line.trim()[0] === "*");
 }
-function printIndentableBlockComment(rawComment) {
+function printIndentableBlockCommentContent(rawComment) {
     const lines = rawComment.split("\n");
     return [
-        "/*",
         join(hardline, lines.map((line, index) => index === 0
             ? line.trimEnd()
             : " " + (index < lines.length - 1 ? line.trim() : line.trimStart()))),
-        "*/",
     ];
 }
+/** Print a doc comment. */
+function printDoc(path, options, print) {
+    const node = path.getValue();
+    const rawComment = options.originalText.slice(node.pos + 3, node.end - 2);
+    const printed = isIndentableBlockComment(rawComment)
+        ? printIndentableBlockCommentContent(rawComment)
+        : rawComment.includes("\n")
+            ? rawComment
+            : ` ${rawComment.trim()} `;
+    return ["/**", printed, "*/"];
+}
 function printDecorators(path, options, print, { tryInline }) {
     const node = path.getValue();
     if (node.decorators.length === 0) {
         return { decorators: "", multiline: false };
     }
-    const shouldBreak = !tryInline || node.decorators.length >= 3 || hasNewlineBetweenOrAfterDecorators(node, options);
+    const shouldBreak = shouldDecoratorBreakLine(path, options, { tryInline });
     const decorators = path.map((x) => [print(x), ifBreak(line, " ")], "decorators");
     return {
         decorators: group([shouldBreak ? breakParent : "", decorators]),
         multiline: shouldBreak,
     };
 }
+/** Check if the decorators of the given node should be broken in sparate line */
+function shouldDecoratorBreakLine(path, options, { tryInline }) {
+    const node = path.getValue();
+    return (!tryInline || node.decorators.length >= 3 || hasNewlineBetweenOrAfterDecorators(node, options));
+}
 /**
  * Check if there is already new lines in between the decorators of the node.
  */
@@ -3338,6 +3395,14 @@ function printAugmentDecoratorArgs(path, options, print) {
         ")",
     ];
 }
+function printDocComments(path, options, print) {
+    const node = path.getValue();
+    if (node.docs === undefined || node.docs.length === 0) {
+        return "";
+    }
+    const docs = path.map((x) => [print(x), line], "docs");
+    return group([...docs, breakParent]);
+}
 function printDirectives(path, options, print) {
     const node = path.getValue();
     if (node.directives === undefined || node.directives.length === 0) {
@@ -3409,7 +3474,9 @@ function printEnumMember(path, options, print) {
     const node = path.getValue();
     const id = path.call(print, "id");
     const value = node.value ? [": ", path.call(print, "value")] : "";
-    const { decorators, multiline } = printDecorators(path, options, print, { tryInline: true });
+    const { decorators, multiline } = printDecorators(path, options, print, {
+        tryInline: DecoratorsTryInline.enumMember,
+    });
     const propertyIndex = path.stack[path.stack.length - 2];
     const isNotFirst = typeof propertyIndex === "number" && propertyIndex > 0;
     return [multiline && isNotFirst ? hardline : "", decorators, id, value];
@@ -3441,7 +3508,9 @@ function printUnionVariantsBlock(path, options, print) {
 function printUnionVariant(path, options, print) {
     const id = path.call(print, "id");
     const value = [": ", path.call(print, "value")];
-    const { decorators } = printDecorators(path, options, print, { tryInline: true });
+    const { decorators } = printDecorators(path, options, print, {
+        tryInline: DecoratorsTryInline.unionVariant,
+    });
     return [decorators, id, value];
 }
 function printInterfaceStatement(path, options, print) {
@@ -3565,18 +3634,19 @@ function printTuple(path, options, print) {
 }
 function printMemberExpression(path, options, print) {
     const node = path.getValue();
-    return [node.base ? [path.call(print, "base"), "."] : "", path.call(print, "id")];
+    return [node.base ? [path.call(print, "base"), node.selector] : "", path.call(print, "id")];
 }
 function printModelExpression(path, options, print) {
     const inBlock = isModelExpressionInBlock(path);
+    const node = path.getValue();
     if (inBlock) {
         return group(printModelPropertiesBlock(path, options, print));
     }
     else {
-        return group([
-            indent(join(", ", path.map((arg) => [softline, print(arg)], "properties"))),
-            softline,
-        ]);
+        const properties = node.properties.length === 0
+            ? ""
+            : indent(joinPropertiesInBlock(path, options, print, ifBreak(",", ", "), softline));
+        return group([properties, softline]);
     }
 }
 function printModelStatement(path, options, print) {
@@ -3610,16 +3680,54 @@ function printModelPropertiesBlock(path, options, print) {
     const tryInline = ((_a = path.getParentNode()) === null || _a === void 0 ? void 0 : _a.kind) === SyntaxKind.TemplateParameterDeclaration;
     const lineDoc = tryInline ? softline : hardline;
     const seperator = isModelAValue(path) ? "," : ";";
-    const body = [
-        lineDoc,
-        join([seperator, lineDoc], path.map((x) => [print(x)], "properties")),
-        hasProperties ? ifBreak(seperator) : "",
-    ];
+    const body = [joinPropertiesInBlock(path, options, print, seperator, lineDoc)];
     if (nodeHasComments) {
         body.push(printDanglingComments(path, options, { sameIndent: true }));
     }
     return group(["{", indent(body), lineDoc, "}"]);
 }
+function joinPropertiesInBlock(path, options, print, separator, regularLine) {
+    const doc = [regularLine];
+    const propertyContainerNode = path.getValue();
+    let newLineBeforeNextProp = false;
+    path.each((item, propertyIndex) => {
+        const isFirst = propertyIndex === 0;
+        const isLast = propertyIndex === propertyContainerNode.properties.length - 1;
+        const shouldWrapInNewLines = shouldWrapPropertyInNewLines(item, options);
+        if ((newLineBeforeNextProp || shouldWrapInNewLines) && !isFirst) {
+            doc.push(hardline);
+            newLineBeforeNextProp = false;
+        }
+        doc.push(print(item));
+        if (isLast) {
+            doc.push(ifBreak(separator));
+        }
+        else {
+            doc.push(separator);
+            doc.push(regularLine);
+            if (shouldWrapInNewLines) {
+                newLineBeforeNextProp = true;
+            }
+        }
+    }, "properties");
+    return doc;
+}
+/**
+ * Check if property item (PropertyNode, SpreadProperty) should be wrapped in new lines.
+ * It can be wrapped for the following reasons:
+ * - has decorators on lines above
+ * - has leading comments
+ */
+function shouldWrapPropertyInNewLines(path, options) {
+    var _a;
+    const node = path.getValue();
+    return (((node.kind === SyntaxKind.ModelProperty || node.kind === SyntaxKind.ProjectionModelProperty) &&
+        shouldDecoratorBreakLine(path, options, {
+            tryInline: DecoratorsTryInline.modelProperty,
+        })) ||
+        hasComments(node, CommentCheckFlags.Leading) ||
+        (node.docs && ((_a = node.docs) === null || _a === void 0 ? void 0 : _a.length) > 0));
+}
 /**
  * Figure out if this model is being used as a definition or value.
  * @returns true if the model is used as a value(e.g. decorator value), false if it is used as a model definition.
@@ -3641,14 +3749,11 @@ function isModelAValue(path) {
 }
 function printModelProperty(path, options, print) {
     const node = path.getValue();
-    const propertyIndex = path.stack[path.stack.length - 2];
-    const isNotFirst = typeof propertyIndex === "number" && propertyIndex > 0;
-    const { decorators, multiline } = printDecorators(path, options, print, {
-        tryInline: true,
+    const { decorators } = printDecorators(path, options, print, {
+        tryInline: DecoratorsTryInline.modelProperty,
     });
     const id = printIdentifier(node.id);
     return [
-        multiline && isNotFirst ? hardline : "",
         printDirectives(path, options, print),
         decorators,
         id,
@@ -4243,15 +4348,42 @@ function createParser(code, options = {}) {
             ...finishNode(0),
         };
     }
+    /** Try to parse doc comments, directives and decorators in any order. */
+    function parseAnnotations({ skipParsingDocNodes } = {}) {
+        const directives = [];
+        const decorators = [];
+        const docs = [];
+        let pos = tokenPos();
+        if (!skipParsingDocNodes) {
+            const [firstPos, addedDocs] = parseDocList();
+            pos = firstPos;
+            for (const doc of addedDocs) {
+                docs.push(doc);
+            }
+        }
+        while (token() === Token.Hash || token() === Token.At) {
+            if (token() === Token.Hash) {
+                directives.push(parseDirectiveExpression());
+            }
+            else if (token() === Token.At) {
+                decorators.push(parseDecoratorExpression());
+            }
+            if (!skipParsingDocNodes) {
+                const [_, addedDocs] = parseDocList();
+                for (const doc of addedDocs) {
+                    docs.push(doc);
+                }
+            }
+        }
+        return { pos, docs, directives, decorators };
+    }
     function parseTypeSpecScriptItemList() {
         const stmts = [];
         let seenBlocklessNs = false;
         let seenDecl = false;
         let seenUsing = false;
         while (token() !== Token.EndOfFile) {
-            const [pos, docs] = parseDocList();
-            const directives = parseDirectiveList();
-            const decorators = parseDecoratorList();
+            const { pos, docs, directives, decorators } = parseAnnotations();
             const tok = token();
             let item;
             switch (tok) {
@@ -4339,9 +4471,7 @@ function createParser(code, options = {}) {
     function parseStatementList() {
         const stmts = [];
         while (token() !== Token.CloseBrace) {
-            const [pos, docs] = parseDocList();
-            const directives = parseDirectiveList();
-            const decorators = parseDecoratorList();
+            const { pos, docs, directives, decorators } = parseAnnotations();
             const tok = token();
             let item;
             switch (tok) {
@@ -5876,13 +6006,15 @@ function createParser(code, options = {}) {
         }
         const docs = [];
         for (const range of docRanges) {
-            const doc = parseRange(1 /* ParseMode.Doc */, innerDocRange(range), parseDoc);
+            const doc = parseRange(1 /* ParseMode.Doc */, innerDocRange(range), () => parseDoc(range));
             docs.push(doc);
+            if (range.comment) {
+                mutate(range.comment).parsedAsDocs = true;
+            }
         }
         return [docRanges[0].pos, docs];
     }
-    function parseDoc() {
-        const pos = tokenPos();
+    function parseDoc(range) {
         const content = [];
         const tags = [];
         loop: while (true) {
@@ -5902,7 +6034,8 @@ function createParser(code, options = {}) {
             kind: SyntaxKind.Doc,
             content,
             tags,
-            ...finishNode(pos),
+            ...finishNode(range.pos),
+            end: range.end,
         };
     }
     function parseDocContent() {
@@ -5915,12 +6048,12 @@ function createParser(code, options = {}) {
             switch (token()) {
                 case Token.DocCodeFenceDelimiter:
                     inCodeFence = !inCodeFence;
-                    nextDocToken();
+                    nextToken();
                     break;
                 case Token.NewLine:
                     parts.push(source.substring(start, tokenPos()));
                     parts.push("\n"); // normalize line endings
-                    nextDocToken();
+                    nextToken();
                     start = tokenPos();
                     while (parseOptional(Token.Whitespace))
                         ;
@@ -5936,10 +6069,10 @@ function createParser(code, options = {}) {
                     if (!inCodeFence) {
                         break loop;
                     }
-                    nextDocToken();
+                    nextToken();
                     break;
                 default:
-                    nextDocToken();
+                    nextToken();
                     break;
             }
         }
@@ -6000,7 +6133,7 @@ function createParser(code, options = {}) {
         let sv;
         if (token() === Token.Identifier) {
             sv = tokenValue();
-            nextDocToken();
+            nextToken();
         }
         else {
             sv = "";
@@ -6043,19 +6176,22 @@ function createParser(code, options = {}) {
                 if (!newLineIsTrivia && token() === Token.NewLine) {
                     break;
                 }
-                if (tokenFlags() & TokenFlags.DocComment) {
-                    docRanges.push({
-                        pos: tokenPos(),
-                        end: tokenEnd(),
-                    });
-                }
+                let comment = undefined;
                 if (options.comments && isComment(token())) {
-                    comments.push({
+                    comment = {
                         kind: token() === Token.SingleLineComment
                             ? SyntaxKind.LineComment
                             : SyntaxKind.BlockComment,
                         pos: tokenPos(),
                         end: tokenEnd(),
+                    };
+                    comments.push(comment);
+                }
+                if (tokenFlags() & TokenFlags.DocComment) {
+                    docRanges.push({
+                        pos: tokenPos(),
+                        end: tokenEnd(),
+                        comment: comment,
                     });
                 }
             }
@@ -6111,13 +6247,9 @@ function createParser(code, options = {}) {
         }
         const items = [];
         while (true) {
-            let pos = tokenPos();
-            let docs;
-            if (!kind.invalidAnnotationTarget) {
-                [pos, docs] = parseDocList();
-            }
-            const directives = parseDirectiveList();
-            const decorators = parseDecoratorList();
+            const { pos, docs, directives, decorators } = parseAnnotations({
+                skipParsingDocNodes: Boolean(kind.invalidAnnotationTarget),
+            });
             if (kind.invalidAnnotationTarget) {
                 reportInvalidDecorators(decorators, kind.invalidAnnotationTarget);
                 reportInvalidDirective(directives, kind.invalidAnnotationTarget);
@@ -6598,12 +6730,14 @@ function isBlocklessNamespace(node) {
 }
 
 function parse(text, parsers, opts) {
-    const result = parse$1(text, { comments: true, docs: false });
+    const result = parse$1(text, { comments: true, docs: true });
     flattenNamespaces(result);
     const errors = result.parseDiagnostics.filter((x) => x.severity === "error");
     if (errors.length > 0 && !result.printable) {
         throw new PrettierParserError(errors[0]);
     }
+    // Remove doc comments as those are handled directly.
+    mutate(result).comments = result.comments.filter((x) => !(x.kind === SyntaxKind.BlockComment && x.parsedAsDocs));
     return result;
 }
 /**