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

package/dist/index.js

@@ -97,15 +97,17 @@ var SyntaxKind;
     SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 87] = "ProjectionDecoratorReferenceExpression";
     SyntaxKind[SyntaxKind["Return"] = 88] = "Return";
     SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 89] = "JsNamespaceDeclaration";
+    SyntaxKind[SyntaxKind["TemplateArgument"] = 90] = "TemplateArgument";
 })(SyntaxKind || (SyntaxKind = {}));
 var IdentifierKind;
 (function (IdentifierKind) {
     IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
-    IdentifierKind[IdentifierKind["Decorator"] = 1] = "Decorator";
-    IdentifierKind[IdentifierKind["Function"] = 2] = "Function";
-    IdentifierKind[IdentifierKind["Using"] = 3] = "Using";
-    IdentifierKind[IdentifierKind["Declaration"] = 4] = "Declaration";
-    IdentifierKind[IdentifierKind["Other"] = 5] = "Other";
+    IdentifierKind[IdentifierKind["TemplateArgument"] = 1] = "TemplateArgument";
+    IdentifierKind[IdentifierKind["Decorator"] = 2] = "Decorator";
+    IdentifierKind[IdentifierKind["Function"] = 3] = "Function";
+    IdentifierKind[IdentifierKind["Using"] = 4] = "Using";
+    IdentifierKind[IdentifierKind["Declaration"] = 5] = "Declaration";
+    IdentifierKind[IdentifierKind["Other"] = 6] = "Other";
 })(IdentifierKind || (IdentifierKind = {}));
 /** Used to explicitly specify that a diagnostic has no target. */
 const NoTarget = Symbol.for("NoTarget");
@@ -117,53 +119,6 @@ var ListenerFlow;
     ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
 })(ListenerFlow || (ListenerFlow = {}));
 
-/**
- * Create a new diagnostics creator.
- * @param diagnostics Map of the potential diagnostics.
- * @param libraryName Optional name of the library if in the scope of a library.
- * @returns @see DiagnosticCreator
- */
-function createDiagnosticCreator(diagnostics, libraryName) {
-    const errorMessage = libraryName
-        ? `It must match one of the code defined in the library '${libraryName}'`
-        : "It must match one of the code defined in the compiler.";
-    function createDiagnostic(diagnostic) {
-        var _a;
-        const diagnosticDef = diagnostics[diagnostic.code];
-        if (!diagnosticDef) {
-            const codeStr = Object.keys(diagnostics)
-                .map((x) => ` - ${x}`)
-                .join("\n");
-            const code = String(diagnostic.code);
-            throw new Error(`Unexpected diagnostic code '${code}'. ${errorMessage}. Defined codes:\n${codeStr}`);
-        }
-        const message = diagnosticDef.messages[(_a = diagnostic.messageId) !== null && _a !== void 0 ? _a : "default"];
-        if (!message) {
-            const codeStr = Object.keys(diagnosticDef.messages)
-                .map((x) => ` - ${x}`)
-                .join("\n");
-            const messageId = String(diagnostic.messageId);
-            const code = String(diagnostic.code);
-            throw new Error(`Unexpected message id '${messageId}'. ${errorMessage} for code '${code}'. Defined codes:\n${codeStr}`);
-        }
-        const messageStr = typeof message === "string" ? message : message(diagnostic.format);
-        return {
-            code: libraryName ? `${libraryName}/${String(diagnostic.code)}` : diagnostic.code.toString(),
-            severity: diagnosticDef.severity,
-            message: messageStr,
-            target: diagnostic.target,
-        };
-    }
-    function reportDiagnostic(program, diagnostic) {
-        const diag = createDiagnostic(diagnostic);
-        program.reportDiagnostic(diag);
-    }
-    return {
-        diagnostics,
-        createDiagnostic,
-        reportDiagnostic,
-    };
-}
 function createSourceFile(text, path) {
     let lineStarts = undefined;
     return {
@@ -328,10 +283,54 @@ function binarySearch(array, value) {
     return ~low;
 }
 
-const globalLibraryUrlsLoadedSym = Symbol.for("TYPESPEC_LIBRARY_URLS_LOADED");
-if (globalThis[globalLibraryUrlsLoadedSym] === undefined) {
-    globalThis[globalLibraryUrlsLoadedSym] = new Set();
+/**
+ * Create a new diagnostics creator.
+ * @param diagnostics Map of the potential diagnostics.
+ * @param libraryName Optional name of the library if in the scope of a library.
+ * @returns @see DiagnosticCreator
+ */
+function createDiagnosticCreator(diagnostics, libraryName) {
+    const errorMessage = libraryName
+        ? `It must match one of the code defined in the library '${libraryName}'`
+        : "It must match one of the code defined in the compiler.";
+    function createDiagnostic(diagnostic) {
+        var _a;
+        const diagnosticDef = diagnostics[diagnostic.code];
+        if (!diagnosticDef) {
+            const codeStr = Object.keys(diagnostics)
+                .map((x) => ` - ${x}`)
+                .join("\n");
+            const code = String(diagnostic.code);
+            throw new Error(`Unexpected diagnostic code '${code}'. ${errorMessage}. Defined codes:\n${codeStr}`);
+        }
+        const message = diagnosticDef.messages[(_a = diagnostic.messageId) !== null && _a !== void 0 ? _a : "default"];
+        if (!message) {
+            const codeStr = Object.keys(diagnosticDef.messages)
+                .map((x) => ` - ${x}`)
+                .join("\n");
+            const messageId = String(diagnostic.messageId);
+            const code = String(diagnostic.code);
+            throw new Error(`Unexpected message id '${messageId}'. ${errorMessage} for code '${code}'. Defined codes:\n${codeStr}`);
+        }
+        const messageStr = typeof message === "string" ? message : message(diagnostic.format);
+        return {
+            code: libraryName ? `${libraryName}/${String(diagnostic.code)}` : diagnostic.code.toString(),
+            severity: diagnosticDef.severity,
+            message: messageStr,
+            target: diagnostic.target,
+        };
+    }
+    function reportDiagnostic(program, diagnostic) {
+        const diag = createDiagnostic(diagnostic);
+        program.reportDiagnostic(diag);
+    }
+    return {
+        diagnostics,
+        createDiagnostic,
+        reportDiagnostic,
+    };
 }
+
 function paramMessage(strings, ...keys) {
     const template = (dict) => {
         const result = [strings[0]];
@@ -544,6 +543,12 @@ const diagnostics = {
             default: "Required template parameters must not follow optional template parameters",
         },
     },
+    "invalid-template-argument-name": {
+        severity: "error",
+        messages: {
+            default: "Template parameter argument names must be valid, bare identifiers.",
+        },
+    },
     "invalid-template-default": {
         severity: "error",
         messages: {
@@ -603,8 +608,11 @@ const diagnostics = {
         messages: {
             default: "Invalid template arguments.",
             notTemplate: "Can't pass template arguments to non-templated type",
-            tooFew: "Too few template arguments provided.",
             tooMany: "Too many template arguments provided.",
+            unknownName: paramMessage `No parameter named '${"name"}' exists in the target template.`,
+            positionalAfterNamed: "Positional template arguments cannot follow named arguments in the same argument list.",
+            missing: paramMessage `Template argument '${"name"}' is required and not specified.`,
+            specifiedAgain: paramMessage `Cannot specify template argument '${"name"}' again.`,
         },
     },
     "intersect-non-model": {
@@ -4659,6 +4667,8 @@ path, options, print) {
             return printUnionVariant(path, options, print);
         case SyntaxKind.TypeReference:
             return printTypeReference(path, options, print);
+        case SyntaxKind.TemplateArgument:
+            return printTemplateArgument(path, options, print);
         case SyntaxKind.ValueOfExpression:
             return printValueOfExpression(path, options, print);
         case SyntaxKind.TemplateParameterDeclaration:
@@ -5407,6 +5417,16 @@ function printTypeReference(path, options, print) {
     const template = printTemplateParameters(path, options, print, "arguments");
     return [type, template];
 }
+function printTemplateArgument(path, _options, print) {
+    if (path.getValue().name !== undefined) {
+        const name = path.call(print, "name");
+        const argument = path.call(print, "argument");
+        return group([name, " = ", argument]);
+    }
+    else {
+        return path.call(print, "argument");
+    }
+}
 function printValueOfExpression(path, options, print) {
     const type = path.call(print, "target");
     return ["valueof ", type];
@@ -6493,7 +6513,7 @@ function createParser(code, options = {}) {
     function parseReferenceExpression(message) {
         const pos = tokenPos();
         const target = parseIdentifierOrMemberExpression(message);
-        const args = parseOptionalList(ListKind.TemplateArguments, parseExpression);
+        const args = parseOptionalList(ListKind.TemplateArguments, parseTemplateArgument);
         return {
             kind: SyntaxKind.TypeReference,
             target,
@@ -6501,6 +6521,41 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseTemplateArgument() {
+        const pos = tokenPos();
+        // Early error recovery for missing identifier followed by eq
+        if (token() === Token.Equals) {
+            error({ code: "token-expected", messageId: "identifier" });
+            nextToken();
+            return {
+                kind: SyntaxKind.TemplateArgument,
+                name: createMissingIdentifier(),
+                argument: parseExpression(),
+                ...finishNode(pos),
+            };
+        }
+        const expr = parseExpression();
+        const eq = parseOptional(Token.Equals);
+        if (eq) {
+            const isBareIdentifier = exprIsBareIdentifier(expr);
+            if (!isBareIdentifier) {
+                error({ code: "invalid-template-argument-name", target: expr });
+            }
+            return {
+                kind: SyntaxKind.TemplateArgument,
+                name: isBareIdentifier ? expr.target : createMissingIdentifier(),
+                argument: parseExpression(),
+                ...finishNode(pos),
+            };
+        }
+        else {
+            return {
+                kind: SyntaxKind.TemplateArgument,
+                argument: expr,
+                ...finishNode(pos),
+            };
+        }
+    }
     function parseAugmentDecorator() {
         const pos = tokenPos();
         parseExpected(Token.AtAt);
@@ -6932,7 +6987,7 @@ function createParser(code, options = {}) {
             target = {
                 kind: SyntaxKind.FunctionParameter,
                 id: createMissingIdentifier(),
-                type: createMissingIdentifier(),
+                type: createMissingTypeReference(),
                 optional: false,
                 rest: false,
                 ...finishNode(pos),
@@ -7842,6 +7897,15 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function createMissingTypeReference() {
+        const pos = tokenPos();
+        return {
+            kind: SyntaxKind.TypeReference,
+            target: createMissingIdentifier(),
+            arguments: [],
+            ...finishNode(pos),
+        };
+    }
     function finishNode(pos) {
         const flags = parseErrorInNextFinishedNode ? 2 /* NodeFlags.ThisNodeHasError */ : 0 /* NodeFlags.None */;
         parseErrorInNextFinishedNode = false;
@@ -8141,6 +8205,11 @@ function createParser(code, options = {}) {
             : undefined;
     }
 }
+function exprIsBareIdentifier(expr) {
+    return (expr.kind === SyntaxKind.TypeReference &&
+        expr.target.kind === SyntaxKind.Identifier &&
+        expr.arguments.length === 0);
+}
 function visitChildren(node, cb) {
     if (node.directives) {
         const result = visitEach(cb, node.directives);
@@ -8296,6 +8365,8 @@ function visitChildren(node, cb) {
             return visitEach(cb, node.decorators);
         case SyntaxKind.TemplateParameterDeclaration:
             return (visitNode(cb, node.id) || visitNode(cb, node.constraint) || visitNode(cb, node.default));
+        case SyntaxKind.TemplateArgument:
+            return (node.name && visitNode(cb, node.name)) || visitNode(cb, node.argument);
         case SyntaxKind.ProjectionLambdaParameterDeclaration:
             return visitNode(cb, node.id);
         case SyntaxKind.ProjectionParameterDeclaration: