@typespec/prettier-plugin-typespec 1.10.0-dev.0 → 1.10.0-dev.1

package/dist/index.js

@@ -316,6 +316,13 @@ var diagnostics = {
   /**
    * Checker
    */
+  "experimental-feature": {
+    severity: "warning",
+    messages: {
+      default: paramMessage`${"feature"} is an experimental feature. It may change in the future or be removed. Use with caution and consider providing feedback on this feature.`,
+      functionDeclarations: "Function declarations are an experimental feature that may change in the future. Use with caution and consider providing feedback to the TypeSpec team."
+    }
+  },
   "using-invalid-ref": {
     severity: "error",
     messages: {
@@ -459,13 +466,15 @@ var diagnostics = {
       model: paramMessage`${"name"} refers to a model type, but is being used as a value here. Use #{} to create an object value.`,
       modelExpression: `Is a model expression type, but is being used as a value here. Use #{} to create an object value.`,
       tuple: `Is a tuple type, but is being used as a value here. Use #[] to create an array value.`,
-      templateConstraint: paramMessage`${"name"} template parameter can be a type but is being used as a value here.`
+      templateConstraint: paramMessage`${"name"} template parameter can be a type but is being used as a value here.`,
+      functionReturn: paramMessage`Function returned a type, but a value was expected.`
     }
   },
   "non-callable": {
     severity: "error",
     messages: {
-      default: paramMessage`Type ${"type"} is not is not callable.`
+      default: paramMessage`Type ${"type"} is not is not callable.`,
+      templateParameter: paramMessage`Template parameter '${"name"} extends ${"constraint"}' is not callable. Ensure it is constrained to a function value or callable type (scalar or scalar constructor).`
     }
   },
   "named-init-required": {
@@ -505,6 +514,14 @@ var diagnostics = {
       default: paramMessage`Property '${"propName"}' is required in type '${"targetType"}' but here is optional.`
     }
   },
+  "parameter-required": {
+    severity: "error",
+    messages: {
+      default: paramMessage`Parameter '${"paramName"}' is required, but optional in the target function.`,
+      missing: paramMessage`Parameter '${"paramName"}' is required, but missing in the target function.`,
+      "rest-to-required": paramMessage`Parameter '${"paramName"}' is required and not satisfied by a rest parameter, as rest parameters are effectively optional.`
+    }
+  },
   "value-in-type": {
     severity: "error",
     messages: {
@@ -603,10 +620,18 @@ var diagnostics = {
       default: "A function declaration must be prefixed with the 'extern' modifier."
     }
   },
-  "function-unsupported": {
+  "function-return": {
     severity: "error",
     messages: {
-      default: "Function are currently not supported."
+      default: "Function implementation returned an invalid result.",
+      "invalid-value": paramMessage`Function implementation returned invalid JS value '${"value"}'.`,
+      unassignable: paramMessage`Implementation of '${"name"}' returned ${"entityKind"} '${"return"}', which is not assignable to the declared return type '${"type"}'.`
+    }
+  },
+  "fn-in-union-expression": {
+    severity: "error",
+    messages: {
+      default: "Function types in anonymous union expressions must be parenthesized."
     }
   },
   "missing-implementation": {
@@ -1261,6 +1286,7 @@ var SyntaxKind;
   SyntaxKind2[SyntaxKind2["ConstStatement"] = 67] = "ConstStatement";
   SyntaxKind2[SyntaxKind2["CallExpression"] = 68] = "CallExpression";
   SyntaxKind2[SyntaxKind2["ScalarConstructor"] = 69] = "ScalarConstructor";
+  SyntaxKind2[SyntaxKind2["FunctionTypeExpression"] = 70] = "FunctionTypeExpression";
 })(SyntaxKind || (SyntaxKind = {}));
 var IdentifierKind;
 (function(IdentifierKind2) {
@@ -3037,14 +3063,14 @@ var Token;
   Token2[Token2["ElseKeyword"] = 64] = "ElseKeyword";
   Token2[Token2["IfKeyword"] = 65] = "IfKeyword";
   Token2[Token2["DecKeyword"] = 66] = "DecKeyword";
-  Token2[Token2["FnKeyword"] = 67] = "FnKeyword";
-  Token2[Token2["ConstKeyword"] = 68] = "ConstKeyword";
-  Token2[Token2["InitKeyword"] = 69] = "InitKeyword";
-  Token2[Token2["__EndStatementKeyword"] = 70] = "__EndStatementKeyword";
-  Token2[Token2["__StartModifierKeyword"] = 70] = "__StartModifierKeyword";
-  Token2[Token2["ExternKeyword"] = 70] = "ExternKeyword";
-  Token2[Token2["__EndModifierKeyword"] = 71] = "__EndModifierKeyword";
-  Token2[Token2["ExtendsKeyword"] = 71] = "ExtendsKeyword";
+  Token2[Token2["ConstKeyword"] = 67] = "ConstKeyword";
+  Token2[Token2["InitKeyword"] = 68] = "InitKeyword";
+  Token2[Token2["__EndStatementKeyword"] = 69] = "__EndStatementKeyword";
+  Token2[Token2["__StartModifierKeyword"] = 69] = "__StartModifierKeyword";
+  Token2[Token2["ExternKeyword"] = 69] = "ExternKeyword";
+  Token2[Token2["__EndModifierKeyword"] = 70] = "__EndModifierKeyword";
+  Token2[Token2["ExtendsKeyword"] = 70] = "ExtendsKeyword";
+  Token2[Token2["FnKeyword"] = 71] = "FnKeyword";
   Token2[Token2["TrueKeyword"] = 72] = "TrueKeyword";
   Token2[Token2["FalseKeyword"] = 73] = "FalseKeyword";
   Token2[Token2["ReturnKeyword"] = 74] = "ReturnKeyword";
@@ -4827,7 +4853,7 @@ function createParser(code, options = {}) {
     const id = parseIdentifier();
     let constraint;
     if (parseOptional(Token.ExtendsKeyword)) {
-      constraint = parseMixedParameterConstraint();
+      constraint = parseMixedConstraint();
     }
     let def;
     if (parseOptional(Token.Equals)) {
@@ -4845,13 +4871,13 @@ function createParser(code, options = {}) {
     if (token() === Token.ValueOfKeyword) {
       return parseValueOfExpression();
     } else if (parseOptional(Token.OpenParen)) {
-      const expr = parseMixedParameterConstraint();
+      const expr = parseMixedConstraint();
       parseExpected(Token.CloseParen);
       return expr;
     }
     return parseIntersectionExpressionOrHigher();
   }
-  function parseMixedParameterConstraint() {
+  function parseMixedConstraint() {
     const pos = tokenPos();
     parseOptional(Token.Bar);
     const node = parseValueOfExpressionOrIntersectionOrHigher();
@@ -5076,6 +5102,14 @@ function createParser(code, options = {}) {
       const expr = parseIntersectionExpressionOrHigher();
       options2.push(expr);
     }
+    for (const fnVariant of options2.filter((n) => n.kind === SyntaxKind.FunctionTypeExpression)) {
+      if (!fnVariant.parenthesized) {
+        error({
+          code: "fn-in-union-expression",
+          target: fnVariant
+        });
+      }
+    }
     return {
       kind: SyntaxKind.UnionExpression,
       options: options2,
@@ -5166,6 +5200,19 @@ function createParser(code, options = {}) {
       }
     }
   }
+  function parseFunctionTypeExpression() {
+    const pos = tokenPos();
+    parseExpected(Token.FnKeyword);
+    const { items: parameters } = parseFunctionParameters();
+    const optionalReturnType = parseOptional(Token.EqualsGreaterThan);
+    const returnType = optionalReturnType ? parseMixedConstraint() : void 0;
+    return {
+      kind: SyntaxKind.FunctionTypeExpression,
+      parameters,
+      returnType,
+      ...finishNode(pos)
+    };
+  }
   function parseReferenceExpression(message) {
     const pos = tokenPos();
     const target = parseIdentifierOrMemberExpression({
@@ -5391,6 +5438,8 @@ function createParser(code, options = {}) {
       switch (token()) {
         case Token.TypeOfKeyword:
           return parseTypeOfExpression();
+        case Token.FnKeyword:
+          return parseFunctionTypeExpression();
         case Token.Identifier:
           return parseCallOrReferenceExpression();
         case Token.StringLiteral:
@@ -5468,7 +5517,7 @@ function createParser(code, options = {}) {
     parseExpected(Token.OpenParen);
     const expr = parseExpression();
     parseExpected(Token.CloseParen);
-    return { ...expr, ...finishNode(pos) };
+    return { parenthesized: true, ...expr, ...finishNode(pos) };
   }
   function parseTupleExpression() {
     const pos = tokenPos();
@@ -5706,7 +5755,7 @@ function createParser(code, options = {}) {
     const { items: parameters } = parseFunctionParameters();
     let returnType;
     if (parseOptional(Token.Colon)) {
-      returnType = parseExpression();
+      returnType = parseMixedConstraint();
     }
     parseExpected(Token.Semicolon);
     return {
@@ -5746,7 +5795,7 @@ function createParser(code, options = {}) {
     const optional = parseOptional(Token.Question);
     let type;
     if (parseOptional(Token.Colon)) {
-      type = parseMixedParameterConstraint();
+      type = parseMixedConstraint();
     }
     return {
       kind: SyntaxKind.FunctionParameter,
@@ -6346,6 +6395,8 @@ function visitChildren(node, cb) {
       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.FunctionTypeExpression:
+      return visitEach(cb, node.parameters) || visitNode(cb, node.returnType);
     case SyntaxKind.FunctionParameter:
       return visitNode(cb, node.id) || visitNode(cb, node.type);
     case SyntaxKind.TypeReference:
@@ -6680,6 +6731,8 @@ function printNode(path, options, print) {
       return printDecoratorDeclarationStatement(path, options, print);
     case SyntaxKind.FunctionDeclarationStatement:
       return printFunctionDeclarationStatement(path, options, print);
+    case SyntaxKind.FunctionTypeExpression:
+      return printFunctionTypeExpression(path, options, print);
     case SyntaxKind.FunctionParameter:
       return printFunctionParameterDeclaration(path, options, print);
     case SyntaxKind.ExternKeyword:
@@ -7391,6 +7444,17 @@ function printFunctionDeclarationStatement(path, options, print) {
   const returnType = node.returnType ? [": ", path.call(print, "returnType")] : "";
   return [printModifiers(path, options, print), "fn ", id, "(", parameters, ")", returnType, ";"];
 }
+function printFunctionTypeExpression(path, options, print) {
+  const node = path.node;
+  const parameters = [
+    group([
+      indent(join(", ", path.map((arg) => [softline, print(arg)], "parameters"))),
+      softline
+    ])
+  ];
+  const returnType = node.returnType ? [" => ", path.call(print, "returnType")] : "";
+  return ["fn", "(", parameters, ")", returnType];
+}
 function printFunctionParameterDeclaration(path, options, print) {
   const node = path.node;
   const id = printIdentifier2(node.id, "allow-reserved");