@typespec/prettier-plugin-typespec 0.44.0 → 0.45.0

package/dist/index.js

@@ -858,49 +858,50 @@ var SyntaxKind;
     SyntaxKind[SyntaxKind["VoidKeyword"] = 36] = "VoidKeyword";
     SyntaxKind[SyntaxKind["NeverKeyword"] = 37] = "NeverKeyword";
     SyntaxKind[SyntaxKind["UnknownKeyword"] = 38] = "UnknownKeyword";
-    SyntaxKind[SyntaxKind["TypeReference"] = 39] = "TypeReference";
-    SyntaxKind[SyntaxKind["ProjectionReference"] = 40] = "ProjectionReference";
-    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 41] = "TemplateParameterDeclaration";
-    SyntaxKind[SyntaxKind["EmptyStatement"] = 42] = "EmptyStatement";
-    SyntaxKind[SyntaxKind["InvalidStatement"] = 43] = "InvalidStatement";
-    SyntaxKind[SyntaxKind["LineComment"] = 44] = "LineComment";
-    SyntaxKind[SyntaxKind["BlockComment"] = 45] = "BlockComment";
-    SyntaxKind[SyntaxKind["Doc"] = 46] = "Doc";
-    SyntaxKind[SyntaxKind["DocText"] = 47] = "DocText";
-    SyntaxKind[SyntaxKind["DocParamTag"] = 48] = "DocParamTag";
-    SyntaxKind[SyntaxKind["DocReturnsTag"] = 49] = "DocReturnsTag";
-    SyntaxKind[SyntaxKind["DocTemplateTag"] = 50] = "DocTemplateTag";
-    SyntaxKind[SyntaxKind["DocUnknownTag"] = 51] = "DocUnknownTag";
-    SyntaxKind[SyntaxKind["Projection"] = 52] = "Projection";
-    SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 53] = "ProjectionParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 54] = "ProjectionModelSelector";
-    SyntaxKind[SyntaxKind["ProjectionModelPropertySelector"] = 55] = "ProjectionModelPropertySelector";
-    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 56] = "ProjectionOperationSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 57] = "ProjectionUnionSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 58] = "ProjectionUnionVariantSelector";
-    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 59] = "ProjectionInterfaceSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 60] = "ProjectionEnumSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 61] = "ProjectionEnumMemberSelector";
-    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 62] = "ProjectionExpressionStatement";
-    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 63] = "ProjectionIfExpression";
-    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 64] = "ProjectionBlockExpression";
-    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 65] = "ProjectionMemberExpression";
-    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 66] = "ProjectionLogicalExpression";
-    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 67] = "ProjectionEqualityExpression";
-    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 68] = "ProjectionUnaryExpression";
-    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 69] = "ProjectionRelationalExpression";
-    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 70] = "ProjectionArithmeticExpression";
-    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 71] = "ProjectionCallExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 72] = "ProjectionLambdaExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 73] = "ProjectionLambdaParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 74] = "ProjectionModelExpression";
-    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 75] = "ProjectionModelProperty";
-    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 76] = "ProjectionModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 77] = "ProjectionSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 78] = "ProjectionTupleExpression";
-    SyntaxKind[SyntaxKind["ProjectionStatement"] = 79] = "ProjectionStatement";
-    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 80] = "ProjectionDecoratorReferenceExpression";
-    SyntaxKind[SyntaxKind["Return"] = 81] = "Return";
+    SyntaxKind[SyntaxKind["ValueOfExpression"] = 39] = "ValueOfExpression";
+    SyntaxKind[SyntaxKind["TypeReference"] = 40] = "TypeReference";
+    SyntaxKind[SyntaxKind["ProjectionReference"] = 41] = "ProjectionReference";
+    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 42] = "TemplateParameterDeclaration";
+    SyntaxKind[SyntaxKind["EmptyStatement"] = 43] = "EmptyStatement";
+    SyntaxKind[SyntaxKind["InvalidStatement"] = 44] = "InvalidStatement";
+    SyntaxKind[SyntaxKind["LineComment"] = 45] = "LineComment";
+    SyntaxKind[SyntaxKind["BlockComment"] = 46] = "BlockComment";
+    SyntaxKind[SyntaxKind["Doc"] = 47] = "Doc";
+    SyntaxKind[SyntaxKind["DocText"] = 48] = "DocText";
+    SyntaxKind[SyntaxKind["DocParamTag"] = 49] = "DocParamTag";
+    SyntaxKind[SyntaxKind["DocReturnsTag"] = 50] = "DocReturnsTag";
+    SyntaxKind[SyntaxKind["DocTemplateTag"] = 51] = "DocTemplateTag";
+    SyntaxKind[SyntaxKind["DocUnknownTag"] = 52] = "DocUnknownTag";
+    SyntaxKind[SyntaxKind["Projection"] = 53] = "Projection";
+    SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 54] = "ProjectionParameterDeclaration";
+    SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 55] = "ProjectionModelSelector";
+    SyntaxKind[SyntaxKind["ProjectionModelPropertySelector"] = 56] = "ProjectionModelPropertySelector";
+    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 57] = "ProjectionOperationSelector";
+    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 58] = "ProjectionUnionSelector";
+    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 59] = "ProjectionUnionVariantSelector";
+    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 60] = "ProjectionInterfaceSelector";
+    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 61] = "ProjectionEnumSelector";
+    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 62] = "ProjectionEnumMemberSelector";
+    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 63] = "ProjectionExpressionStatement";
+    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 64] = "ProjectionIfExpression";
+    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 65] = "ProjectionBlockExpression";
+    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 66] = "ProjectionMemberExpression";
+    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 67] = "ProjectionLogicalExpression";
+    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 68] = "ProjectionEqualityExpression";
+    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 69] = "ProjectionUnaryExpression";
+    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 70] = "ProjectionRelationalExpression";
+    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 71] = "ProjectionArithmeticExpression";
+    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 72] = "ProjectionCallExpression";
+    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 73] = "ProjectionLambdaExpression";
+    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 74] = "ProjectionLambdaParameterDeclaration";
+    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 75] = "ProjectionModelExpression";
+    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 76] = "ProjectionModelProperty";
+    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 77] = "ProjectionModelSpreadProperty";
+    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 78] = "ProjectionSpreadProperty";
+    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 79] = "ProjectionTupleExpression";
+    SyntaxKind[SyntaxKind["ProjectionStatement"] = 80] = "ProjectionStatement";
+    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 81] = "ProjectionDecoratorReferenceExpression";
+    SyntaxKind[SyntaxKind["Return"] = 82] = "Return";
 })(SyntaxKind = SyntaxKind || (SyntaxKind = {}));
 var IdentifierKind;
 (function (IdentifierKind) {
@@ -1020,6 +1021,21 @@ const diagnostics = {
             default: paramMessage `${"message"}`,
         },
     },
+    /**
+     * Init templates
+     */
+    "init-template-invalid-json": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Unable to parse ${"url"}: ${"message"}. Check that the template URL is correct.`,
+        },
+    },
+    "init-template-download-failed": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Failed to download template from ${"url"}: ${"message"}. Check that the template URL is correct.`,
+        },
+    },
     /**
      * Parser errors.
      */
@@ -1511,12 +1527,6 @@ const diagnostics = {
             default: paramMessage `Requested emitter package ${"emitterPackage"} does not provide an "onEmit" function.`,
         },
     },
-    "emitter-not-found": {
-        severity: "warning",
-        messages: {
-            default: paramMessage `Emitter with name ${"emitterName"} is not found.`,
-        },
-    },
     "missing-import": {
         severity: "error",
         messages: {
@@ -1604,8 +1614,8 @@ const diagnostics = {
         severity: "error",
         messages: {
             default: "Invalid encoding",
-            wrongType: paramMessage `Encoding '${"encoding"}' cannot be used on type ${"type"}. Expected a ${"expected"}.`,
-            wrongEncodingType: paramMessage `Encoding '${"encoding"}' cannot be used on type ${"type"}. Expected a ${"expected"}.`,
+            wrongType: paramMessage `Encoding '${"encoding"}' cannot be used on type '${"type"}'. Expected: ${"expected"}.`,
+            wrongEncodingType: paramMessage `Encoding '${"encoding"}' on type '${"type"}' is expected to be serialized as '${"expected"}' but got '${"actual"}'.`,
         },
     },
     /**
@@ -1987,27 +1997,28 @@ var Token;
     Token[Token["IfKeyword"] = 60] = "IfKeyword";
     Token[Token["DecKeyword"] = 61] = "DecKeyword";
     Token[Token["FnKeyword"] = 62] = "FnKeyword";
+    Token[Token["ValueOfKeyword"] = 63] = "ValueOfKeyword";
     // Add new statement keyword above
-    /** @internal */ Token[Token["__EndStatementKeyword"] = 63] = "__EndStatementKeyword";
+    /** @internal */ Token[Token["__EndStatementKeyword"] = 64] = "__EndStatementKeyword";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__StartModifierKeyword"] = 63] = "__StartModifierKeyword";
-    Token[Token["ExternKeyword"] = 63] = "ExternKeyword";
-    /** @internal */ Token[Token["__EndModifierKeyword"] = 64] = "__EndModifierKeyword";
+    /** @internal */ Token[Token["__StartModifierKeyword"] = 64] = "__StartModifierKeyword";
+    Token[Token["ExternKeyword"] = 64] = "ExternKeyword";
+    /** @internal */ Token[Token["__EndModifierKeyword"] = 65] = "__EndModifierKeyword";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
     // Other keywords
-    Token[Token["ExtendsKeyword"] = 64] = "ExtendsKeyword";
-    Token[Token["TrueKeyword"] = 65] = "TrueKeyword";
-    Token[Token["FalseKeyword"] = 66] = "FalseKeyword";
-    Token[Token["ReturnKeyword"] = 67] = "ReturnKeyword";
-    Token[Token["VoidKeyword"] = 68] = "VoidKeyword";
-    Token[Token["NeverKeyword"] = 69] = "NeverKeyword";
-    Token[Token["UnknownKeyword"] = 70] = "UnknownKeyword";
+    Token[Token["ExtendsKeyword"] = 65] = "ExtendsKeyword";
+    Token[Token["TrueKeyword"] = 66] = "TrueKeyword";
+    Token[Token["FalseKeyword"] = 67] = "FalseKeyword";
+    Token[Token["ReturnKeyword"] = 68] = "ReturnKeyword";
+    Token[Token["VoidKeyword"] = 69] = "VoidKeyword";
+    Token[Token["NeverKeyword"] = 70] = "NeverKeyword";
+    Token[Token["UnknownKeyword"] = 71] = "UnknownKeyword";
     // Add new non-statement keyword above
-    /** @internal */ Token[Token["__EndKeyword"] = 71] = "__EndKeyword";
+    /** @internal */ Token[Token["__EndKeyword"] = 72] = "__EndKeyword";
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__Count"] = 71] = "__Count";
+    /** @internal */ Token[Token["__Count"] = 72] = "__Count";
 })(Token = Token || (Token = {}));
 /** @internal */
 const TokenDisplay = getTokenDisplayTable([
@@ -2074,6 +2085,7 @@ const TokenDisplay = getTokenDisplayTable([
     [Token.IfKeyword, "'if'"],
     [Token.DecKeyword, "'dec'"],
     [Token.FnKeyword, "'fn'"],
+    [Token.ValueOfKeyword, "'valueof'"],
     [Token.ExtendsKeyword, "'extends'"],
     [Token.TrueKeyword, "'true'"],
     [Token.FalseKeyword, "'false'"],
@@ -2102,6 +2114,7 @@ const Keywords = new Map([
     ["alias", Token.AliasKeyword],
     ["dec", Token.DecKeyword],
     ["fn", Token.FnKeyword],
+    ["valueof", Token.ValueOfKeyword],
     ["true", Token.TrueKeyword],
     ["false", Token.FalseKeyword],
     ["return", Token.ReturnKeyword],
@@ -2948,6 +2961,7 @@ function addStatementDecoratorComment(comment) {
         (enclosingNode.kind === SyntaxKind.NamespaceStatement ||
             enclosingNode.kind === SyntaxKind.ModelStatement ||
             enclosingNode.kind === SyntaxKind.EnumStatement ||
+            enclosingNode.kind === SyntaxKind.OperationStatement ||
             enclosingNode.kind === SyntaxKind.ModelProperty ||
             enclosingNode.kind === SyntaxKind.EnumMember ||
             enclosingNode.kind === SyntaxKind.UnionStatement)) {
@@ -3107,6 +3121,8 @@ path, options, print) {
             return printUnionVariant(path, options, print);
         case SyntaxKind.TypeReference:
             return printTypeReference(path, options, print);
+        case SyntaxKind.ValueOfExpression:
+            return printValueOfExpression(path, options, print);
         case SyntaxKind.TemplateParameterDeclaration:
             return printTemplateParameterDeclaration(path, options, print);
         case SyntaxKind.ModelSpreadProperty:
@@ -3780,6 +3796,10 @@ function printTypeReference(path, options, print) {
     const template = printTemplateParameters(path, options, print, "arguments");
     return [type, template];
 }
+function printValueOfExpression(path, options, print) {
+    const type = path.call(print, "target");
+    return ["valueof ", type];
+}
 function printTemplateParameterDeclaration(path, options, print) {
     const node = path.getValue();
     return [
@@ -4781,6 +4801,16 @@ function createParser(code, options = {}) {
         }
         return expr;
     }
+    function parseValueOfExpression() {
+        const pos = tokenPos();
+        parseExpected(Token.ValueOfKeyword);
+        const target = parseExpression();
+        return {
+            kind: SyntaxKind.ValueOfExpression,
+            target,
+            ...finishNode(pos),
+        };
+    }
     function parseReferenceExpression(message) {
         const pos = tokenPos();
         const target = parseIdentifierOrMemberExpression(message);
@@ -4954,6 +4984,8 @@ function createParser(code, options = {}) {
     function parsePrimaryExpression() {
         while (true) {
             switch (token()) {
+                case Token.ValueOfKeyword:
+                    return parseValueOfExpression();
                 case Token.Identifier:
                     return parseReferenceExpression();
                 case Token.StringLiteral:
@@ -5057,12 +5089,13 @@ function createParser(code, options = {}) {
     }
     function parseNumericLiteral() {
         const pos = tokenPos();
-        const text = tokenValue();
-        const value = Number(text);
+        const valueAsString = tokenValue();
+        const value = Number(valueAsString);
         parseExpected(Token.NumericLiteral);
         return {
             kind: SyntaxKind.NumericLiteral,
             value,
+            valueAsString,
             ...finishNode(pos),
         };
     }
@@ -5797,7 +5830,7 @@ function createParser(code, options = {}) {
         };
     }
     function parseDocList() {
-        if (docRanges.length === 0 || !options.docs) {
+        if (docRanges.length === 0 || options.docs === false) {
             return [tokenPos(), []];
         }
         const docs = [];
@@ -6317,7 +6350,7 @@ function isBlocklessNamespace(node) {
 }
 
 function parse(text, parsers, opts) {
-    const result = parse$1(text, { comments: true });
+    const result = parse$1(text, { comments: true, docs: false });
     const errors = result.parseDiagnostics.filter((x) => x.severity === "error");
     if (errors.length > 0 && !result.printable) {
         throw new PrettierParserError(errors[0]);