@typespec/prettier-plugin-typespec 0.41.0 → 0.43.0

package/dist/index.js

@@ -874,30 +874,33 @@ var SyntaxKind;
     SyntaxKind[SyntaxKind["Projection"] = 52] = "Projection";
     SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 53] = "ProjectionParameterDeclaration";
     SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 54] = "ProjectionModelSelector";
-    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 55] = "ProjectionOperationSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 56] = "ProjectionUnionSelector";
-    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 57] = "ProjectionInterfaceSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 58] = "ProjectionEnumSelector";
-    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 59] = "ProjectionExpressionStatement";
-    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 60] = "ProjectionIfExpression";
-    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 61] = "ProjectionBlockExpression";
-    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 62] = "ProjectionMemberExpression";
-    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 63] = "ProjectionLogicalExpression";
-    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 64] = "ProjectionEqualityExpression";
-    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 65] = "ProjectionUnaryExpression";
-    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 66] = "ProjectionRelationalExpression";
-    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 67] = "ProjectionArithmeticExpression";
-    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 68] = "ProjectionCallExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 69] = "ProjectionLambdaExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 70] = "ProjectionLambdaParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 71] = "ProjectionModelExpression";
-    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 72] = "ProjectionModelProperty";
-    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 73] = "ProjectionModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 74] = "ProjectionSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 75] = "ProjectionTupleExpression";
-    SyntaxKind[SyntaxKind["ProjectionStatement"] = 76] = "ProjectionStatement";
-    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 77] = "ProjectionDecoratorReferenceExpression";
-    SyntaxKind[SyntaxKind["Return"] = 78] = "Return";
+    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 || (SyntaxKind = {}));
 var IdentifierKind;
 (function (IdentifierKind) {
@@ -1235,7 +1238,7 @@ const diagnostics = {
             inDecorator: paramMessage `Cannot resolve ${"id"} in decorator`,
             underNamespace: paramMessage `Namespace ${"namespace"} doesn't have member ${"id"}`,
             underContainer: paramMessage `${"kind"} doesn't have member ${"id"}`,
-            node: paramMessage `Cannot resolve '${"id"}' in non-namespace node ${"nodeName"}`,
+            node: paramMessage `Cannot resolve '${"id"}' in node ${"nodeName"} since it has no members. Did you mean to use "::" instead of "."?`,
         },
     },
     "duplicate-property": {
@@ -1250,12 +1253,6 @@ const diagnostics = {
             default: paramMessage `Model has an inherited property named ${"propName"} of type ${"propType"} which cannot override type ${"parentType"}`,
         },
     },
-    "override-property-intrinsic": {
-        severity: "error",
-        messages: {
-            default: paramMessage `Model has an inherited property named ${"propName"} of type ${"propType"} which can only override an intrinsic type on the parent property, not ${"parentType"}`,
-        },
-    },
     "extend-scalar": {
         severity: "error",
         messages: {
@@ -1419,6 +1416,12 @@ const diagnostics = {
             default: paramMessage `Path "${"path"}" cannot be relative. Use {cwd} or {project-root} to specify what the path should be relative to.`,
         },
     },
+    "config-path-not-found": {
+        severity: "error",
+        messages: {
+            default: paramMessage `No configuration file found at config path "${"path"}".`,
+        },
+    },
     /**
      * Program
      */
@@ -3124,14 +3127,20 @@ path, options, print) {
             return printProjectionStatement(path, options, print);
         case SyntaxKind.ProjectionModelSelector:
             return "model";
+        case SyntaxKind.ProjectionModelPropertySelector:
+            return "modelproperty";
         case SyntaxKind.ProjectionOperationSelector:
             return "op";
         case SyntaxKind.ProjectionUnionSelector:
             return "union";
+        case SyntaxKind.ProjectionUnionVariantSelector:
+            return "unionvariant";
         case SyntaxKind.ProjectionInterfaceSelector:
             return "interface";
         case SyntaxKind.ProjectionEnumSelector:
             return "enum";
+        case SyntaxKind.ProjectionEnumMemberSelector:
+            return "enummember";
         case SyntaxKind.Projection:
             return printProjection(path, options, print);
         case SyntaxKind.ProjectionParameterDeclaration:
@@ -3837,20 +3846,17 @@ function printBooleanLiteral(path, options) {
     return node.value ? "true" : "false";
 }
 function printProjectionStatement(path, options, print) {
-    const node = path.getValue();
     const selector = path.call(print, "selector");
     const id = path.call(print, "id");
-    const to = node.to ? [hardline, path.call(print, "to")] : "";
-    const from = node.from ? [hardline, path.call(print, "from")] : "";
-    const body = [to, from];
+    const projections = path.map(print, "projections").flatMap((x) => [hardline, x]);
     return [
         "projection ",
         selector,
         "#",
         id,
         " {",
-        indent(body),
-        node.to || node.from ? hardline : "",
+        indent(projections),
+        projections.length > 0 ? hardline : "",
         "}",
     ];
 }
@@ -3858,7 +3864,15 @@ function printProjection(path, options, print) {
     const node = path.getValue();
     const params = printProjectionParameters(path, options, print);
     const body = printProjectionExpressionStatements(path, options, print, "body");
-    return [node.direction, params, " {", indent(body), hardline, "}"];
+    return [
+        ...node.modifierIds.flatMap((i) => [i.sv, " "]),
+        node.directionId.sv,
+        params,
+        " {",
+        indent(body),
+        hardline,
+        "}",
+    ];
 }
 function printProjectionParameters(path, options, print) {
     const node = path.getValue();
@@ -4906,20 +4920,35 @@ function createParser(code, options = {}) {
             message,
             recoverFromKeyword,
         });
-        while (parseOptional(Token.Dot)) {
-            base = {
-                kind: SyntaxKind.MemberExpression,
-                base,
-                // Error recovery: false arg here means don't treat a keyword as an
-                // identifier after `.` in member expression. Otherwise we will
-                // parse `@Outer.<missing identifier> model M{}` as having decorator
-                // `@Outer.model` applied to invalid statement `M {}` instead of
-                // having incomplete decorator `@Outer.` applied to `model M {}`.
-                id: parseIdentifier({
-                    recoverFromKeyword: false,
-                }),
-                ...finishNode(pos),
-            };
+        while (token() !== Token.EndOfFile) {
+            if (parseOptional(Token.Dot)) {
+                base = {
+                    kind: SyntaxKind.MemberExpression,
+                    base,
+                    // Error recovery: false arg here means don't treat a keyword as an
+                    // identifier after `.` in member expression. Otherwise we will
+                    // parse `@Outer.<missing identifier> model M{}` as having decorator
+                    // `@Outer.model` applied to invalid statement `M {}` instead of
+                    // having incomplete decorator `@Outer.` applied to `model M {}`.
+                    id: parseIdentifier({
+                        recoverFromKeyword: false,
+                    }),
+                    selector: ".",
+                    ...finishNode(pos),
+                };
+            }
+            else if (parseOptional(Token.ColonColon)) {
+                base = {
+                    kind: SyntaxKind.MemberExpression,
+                    base,
+                    id: parseIdentifier(),
+                    selector: "::",
+                    ...finishNode(pos),
+                };
+            }
+            else {
+                break;
+            }
         }
         return base;
     }
@@ -5200,37 +5229,51 @@ function createParser(code, options = {}) {
         parseExpected(Token.Hash);
         const id = parseIdentifier();
         parseExpected(Token.OpenBrace);
-        let from, to;
-        let proj1, proj2;
-        if (token() === Token.Identifier) {
-            proj1 = parseProjection();
-            if (token() === Token.Identifier) {
-                proj2 = parseProjection();
+        const projectionMap = new Map();
+        const projections = [];
+        while (token() === Token.Identifier) {
+            const projection = parseProjection();
+            if (projection.direction !== "<error>") {
+                if (projectionMap.has(projection.direction)) {
+                    error({ code: "duplicate-symbol", target: projection, format: { name: "projection" } });
+                }
+                else {
+                    projectionMap.set(projection.direction, projection);
+                }
             }
-        }
-        if (proj1 && proj2 && proj1.direction === proj2.direction) {
-            error({ code: "duplicate-symbol", target: proj2, format: { name: "projection" } });
-        }
-        else if (proj1) {
-            [to, from] = proj1.direction === "to" ? [proj1, proj2] : [proj2, proj1];
+            // NOTE: Don't drop projections with error in direction definition from the AST.
+            projections.push(projection);
         }
         parseExpected(Token.CloseBrace);
         return {
             kind: SyntaxKind.ProjectionStatement,
             selector,
-            from,
-            to,
+            projections,
+            preTo: projectionMap.get("pre_to"),
+            preFrom: projectionMap.get("pre_from"),
+            from: projectionMap.get("from"),
+            to: projectionMap.get("to"),
             id,
             ...finishNode(pos),
         };
     }
     function parseProjection() {
         const pos = tokenPos();
-        const directionId = parseIdentifier({ message: "projectionDirection" });
+        let directionId = parseIdentifier({ message: "projectionDirection" });
         let direction;
-        if (directionId.sv !== "from" && directionId.sv !== "to") {
+        const modifierIds = [];
+        let isPre = false;
+        if (directionId.sv === "pre") {
+            isPre = true;
+            modifierIds.push(directionId);
+            directionId = parseIdentifier({ message: "projectionDirection" });
+        }
+        if (directionId.sv !== "to" && directionId.sv !== "from") {
             error({ code: "token-expected", messageId: "projectionDirection" });
-            direction = "from";
+            direction = "<error>";
+        }
+        else if (isPre) {
+            direction = directionId.sv === "to" ? "pre_to" : "pre_from";
         }
         else {
             direction = directionId.sv;
@@ -5250,6 +5293,7 @@ function createParser(code, options = {}) {
             body,
             direction,
             directionId,
+            modifierIds,
             parameters,
             ...finishNode(pos),
         };
@@ -5681,7 +5725,27 @@ function createParser(code, options = {}) {
         const selectorTok = expectTokenIsOneOf(Token.Identifier, Token.ModelKeyword, Token.OpKeyword, Token.InterfaceKeyword, Token.UnionKeyword, Token.EnumKeyword);
         switch (selectorTok) {
             case Token.Identifier:
-                return parseIdentifierOrMemberExpression(undefined, true);
+                const id = parseIdentifierOrMemberExpression(undefined, true);
+                if (id.kind === SyntaxKind.Identifier) {
+                    switch (id.sv) {
+                        case "modelproperty":
+                            return {
+                                kind: SyntaxKind.ProjectionModelPropertySelector,
+                                ...finishNode(pos),
+                            };
+                        case "unionvariant":
+                            return {
+                                kind: SyntaxKind.ProjectionUnionVariantSelector,
+                                ...finishNode(pos),
+                            };
+                        case "enummember":
+                            return {
+                                kind: SyntaxKind.ProjectionEnumMemberSelector,
+                                ...finishNode(pos),
+                            };
+                    }
+                }
+                return id;
             case Token.ModelKeyword:
                 nextToken();
                 return {