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

package/dist/index.js

@@ -316,6 +316,14 @@ 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.",
+      internal: `Internal symbols are experimental and may be changed in a future release. Use with caution. Suppress this message ('#suppress "experimental-feature"') to silence this warning.`
+    }
+  },
   "using-invalid-ref": {
     severity: "error",
     messages: {
@@ -390,7 +398,8 @@ var diagnostics = {
       underNamespace: paramMessage`Namespace ${"namespace"} doesn't have member ${"id"}`,
       member: paramMessage`${"kind"} doesn't have member ${"id"}`,
       metaProperty: paramMessage`${"kind"} doesn't have meta property ${"id"}`,
-      node: paramMessage`Cannot resolve '${"id"}' in node ${"nodeName"} since it has no members. Did you mean to use "::" instead of "."?`
+      node: paramMessage`Cannot resolve '${"id"}' in node ${"nodeName"} since it has no members. Did you mean to use "::" instead of "."?`,
+      internal: paramMessage`Symbol '${"id"}' is internal and can only be accessed from within its declaring package.`
     }
   },
   "duplicate-property": {
@@ -459,13 +468,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 +516,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: {
@@ -591,22 +610,26 @@ var diagnostics = {
       default: "A rest parameter must be of an array type."
     }
   },
-  "decorator-extern": {
+  "invalid-modifier": {
     severity: "error",
     messages: {
-      default: "A decorator declaration must be prefixed with the 'extern' modifier."
+      default: paramMessage`Modifier '${"modifier"}' is invalid.`,
+      "missing-required": paramMessage`Declaration of type '${"nodeKind"}' is missing required modifier '${"modifier"}'.`,
+      "not-allowed": paramMessage`Modifier '${"modifier"}' cannot be used on declarations of type '${"nodeKind"}'.`
     }
   },
-  "function-extern": {
+  "function-return": {
     severity: "error",
     messages: {
-      default: "A function declaration must be prefixed with the 'extern' modifier."
+      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"}'.`
     }
   },
-  "function-unsupported": {
+  "fn-in-union-expression": {
     severity: "error",
     messages: {
-      default: "Function are currently not supported."
+      default: "Function types in anonymous union expressions must be parenthesized."
     }
   },
   "missing-implementation": {
@@ -1261,6 +1284,8 @@ var SyntaxKind;
   SyntaxKind2[SyntaxKind2["ConstStatement"] = 67] = "ConstStatement";
   SyntaxKind2[SyntaxKind2["CallExpression"] = 68] = "CallExpression";
   SyntaxKind2[SyntaxKind2["ScalarConstructor"] = 69] = "ScalarConstructor";
+  SyntaxKind2[SyntaxKind2["InternalKeyword"] = 70] = "InternalKeyword";
+  SyntaxKind2[SyntaxKind2["FunctionTypeExpression"] = 71] = "FunctionTypeExpression";
 })(SyntaxKind || (SyntaxKind = {}));
 var IdentifierKind;
 (function(IdentifierKind2) {
@@ -2855,6 +2880,52 @@ function lookupInNonAsciiMap(codePoint, map) {
   return false;
 }
 
+// ../compiler/dist/src/core/modifiers.js
+var DEFAULT_COMPATIBILITY = {
+  allowed: 4,
+  required: 0
+};
+var NO_MODIFIERS = {
+  allowed: 0,
+  required: 0
+};
+var SYNTAX_MODIFIERS = {
+  [SyntaxKind.NamespaceStatement]: NO_MODIFIERS,
+  [SyntaxKind.OperationStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.ModelStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.ScalarStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.InterfaceStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.UnionStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.EnumStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.AliasStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.ConstStatement]: DEFAULT_COMPATIBILITY,
+  [SyntaxKind.DecoratorDeclarationStatement]: {
+    allowed: 6,
+    required: 2
+  },
+  [SyntaxKind.FunctionDeclarationStatement]: {
+    allowed: 6,
+    required: 2
+  }
+};
+function modifiersToFlags(modifiers) {
+  let flags = 0;
+  for (const modifier of modifiers) {
+    flags |= modifierToFlag(modifier);
+  }
+  return flags;
+}
+function modifierToFlag(modifier) {
+  switch (modifier.kind) {
+    case SyntaxKind.ExternKeyword:
+      return 2;
+    case SyntaxKind.InternalKeyword:
+      return 4;
+    default:
+      compilerAssert(false, `Unknown modifier kind: ${modifier.kind}`);
+  }
+}
+
 // ../compiler/dist/src/core/helpers/syntax-utils.js
 function printIdentifier(sv, context = "disallow-reserved") {
   if (needBacktick(sv, context)) {
@@ -2868,8 +2939,14 @@ function needBacktick(sv, context) {
   if (sv.length === 0) {
     return false;
   }
-  if (context === "allow-reserved" && ReservedKeywords.has(sv)) {
-    return false;
+  if (context === "allow-reserved") {
+    if (ReservedKeywords.has(sv)) {
+      return false;
+    }
+    const kwToken = Keywords.get(sv);
+    if (kwToken !== void 0 && isModifier(kwToken)) {
+      return false;
+    }
   }
   if (Keywords.has(sv)) {
     return true;
@@ -3037,60 +3114,60 @@ 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["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["InternalKeyword"] = 70] = "InternalKeyword";
   Token2[Token2["__EndModifierKeyword"] = 71] = "__EndModifierKeyword";
   Token2[Token2["ExtendsKeyword"] = 71] = "ExtendsKeyword";
-  Token2[Token2["TrueKeyword"] = 72] = "TrueKeyword";
-  Token2[Token2["FalseKeyword"] = 73] = "FalseKeyword";
-  Token2[Token2["ReturnKeyword"] = 74] = "ReturnKeyword";
-  Token2[Token2["VoidKeyword"] = 75] = "VoidKeyword";
-  Token2[Token2["NeverKeyword"] = 76] = "NeverKeyword";
-  Token2[Token2["UnknownKeyword"] = 77] = "UnknownKeyword";
-  Token2[Token2["ValueOfKeyword"] = 78] = "ValueOfKeyword";
-  Token2[Token2["TypeOfKeyword"] = 79] = "TypeOfKeyword";
-  Token2[Token2["__EndKeyword"] = 80] = "__EndKeyword";
-  Token2[Token2["__StartReservedKeyword"] = 80] = "__StartReservedKeyword";
-  Token2[Token2["StatemachineKeyword"] = 80] = "StatemachineKeyword";
-  Token2[Token2["MacroKeyword"] = 81] = "MacroKeyword";
-  Token2[Token2["PackageKeyword"] = 82] = "PackageKeyword";
-  Token2[Token2["MetadataKeyword"] = 83] = "MetadataKeyword";
-  Token2[Token2["EnvKeyword"] = 84] = "EnvKeyword";
-  Token2[Token2["ArgKeyword"] = 85] = "ArgKeyword";
-  Token2[Token2["DeclareKeyword"] = 86] = "DeclareKeyword";
-  Token2[Token2["ArrayKeyword"] = 87] = "ArrayKeyword";
-  Token2[Token2["StructKeyword"] = 88] = "StructKeyword";
-  Token2[Token2["RecordKeyword"] = 89] = "RecordKeyword";
-  Token2[Token2["ModuleKeyword"] = 90] = "ModuleKeyword";
-  Token2[Token2["ModKeyword"] = 91] = "ModKeyword";
-  Token2[Token2["SymKeyword"] = 92] = "SymKeyword";
-  Token2[Token2["ContextKeyword"] = 93] = "ContextKeyword";
-  Token2[Token2["PropKeyword"] = 94] = "PropKeyword";
-  Token2[Token2["PropertyKeyword"] = 95] = "PropertyKeyword";
-  Token2[Token2["ScenarioKeyword"] = 96] = "ScenarioKeyword";
-  Token2[Token2["PubKeyword"] = 97] = "PubKeyword";
-  Token2[Token2["SubKeyword"] = 98] = "SubKeyword";
-  Token2[Token2["TypeRefKeyword"] = 99] = "TypeRefKeyword";
-  Token2[Token2["TraitKeyword"] = 100] = "TraitKeyword";
-  Token2[Token2["ThisKeyword"] = 101] = "ThisKeyword";
-  Token2[Token2["SelfKeyword"] = 102] = "SelfKeyword";
-  Token2[Token2["SuperKeyword"] = 103] = "SuperKeyword";
-  Token2[Token2["KeyofKeyword"] = 104] = "KeyofKeyword";
-  Token2[Token2["WithKeyword"] = 105] = "WithKeyword";
-  Token2[Token2["ImplementsKeyword"] = 106] = "ImplementsKeyword";
-  Token2[Token2["ImplKeyword"] = 107] = "ImplKeyword";
-  Token2[Token2["SatisfiesKeyword"] = 108] = "SatisfiesKeyword";
-  Token2[Token2["FlagKeyword"] = 109] = "FlagKeyword";
-  Token2[Token2["AutoKeyword"] = 110] = "AutoKeyword";
-  Token2[Token2["PartialKeyword"] = 111] = "PartialKeyword";
-  Token2[Token2["PrivateKeyword"] = 112] = "PrivateKeyword";
-  Token2[Token2["PublicKeyword"] = 113] = "PublicKeyword";
-  Token2[Token2["ProtectedKeyword"] = 114] = "ProtectedKeyword";
-  Token2[Token2["InternalKeyword"] = 115] = "InternalKeyword";
+  Token2[Token2["FnKeyword"] = 72] = "FnKeyword";
+  Token2[Token2["TrueKeyword"] = 73] = "TrueKeyword";
+  Token2[Token2["FalseKeyword"] = 74] = "FalseKeyword";
+  Token2[Token2["ReturnKeyword"] = 75] = "ReturnKeyword";
+  Token2[Token2["VoidKeyword"] = 76] = "VoidKeyword";
+  Token2[Token2["NeverKeyword"] = 77] = "NeverKeyword";
+  Token2[Token2["UnknownKeyword"] = 78] = "UnknownKeyword";
+  Token2[Token2["ValueOfKeyword"] = 79] = "ValueOfKeyword";
+  Token2[Token2["TypeOfKeyword"] = 80] = "TypeOfKeyword";
+  Token2[Token2["__EndKeyword"] = 81] = "__EndKeyword";
+  Token2[Token2["__StartReservedKeyword"] = 81] = "__StartReservedKeyword";
+  Token2[Token2["StatemachineKeyword"] = 81] = "StatemachineKeyword";
+  Token2[Token2["MacroKeyword"] = 82] = "MacroKeyword";
+  Token2[Token2["PackageKeyword"] = 83] = "PackageKeyword";
+  Token2[Token2["MetadataKeyword"] = 84] = "MetadataKeyword";
+  Token2[Token2["EnvKeyword"] = 85] = "EnvKeyword";
+  Token2[Token2["ArgKeyword"] = 86] = "ArgKeyword";
+  Token2[Token2["DeclareKeyword"] = 87] = "DeclareKeyword";
+  Token2[Token2["ArrayKeyword"] = 88] = "ArrayKeyword";
+  Token2[Token2["StructKeyword"] = 89] = "StructKeyword";
+  Token2[Token2["RecordKeyword"] = 90] = "RecordKeyword";
+  Token2[Token2["ModuleKeyword"] = 91] = "ModuleKeyword";
+  Token2[Token2["ModKeyword"] = 92] = "ModKeyword";
+  Token2[Token2["SymKeyword"] = 93] = "SymKeyword";
+  Token2[Token2["ContextKeyword"] = 94] = "ContextKeyword";
+  Token2[Token2["PropKeyword"] = 95] = "PropKeyword";
+  Token2[Token2["PropertyKeyword"] = 96] = "PropertyKeyword";
+  Token2[Token2["ScenarioKeyword"] = 97] = "ScenarioKeyword";
+  Token2[Token2["PubKeyword"] = 98] = "PubKeyword";
+  Token2[Token2["SubKeyword"] = 99] = "SubKeyword";
+  Token2[Token2["TypeRefKeyword"] = 100] = "TypeRefKeyword";
+  Token2[Token2["TraitKeyword"] = 101] = "TraitKeyword";
+  Token2[Token2["ThisKeyword"] = 102] = "ThisKeyword";
+  Token2[Token2["SelfKeyword"] = 103] = "SelfKeyword";
+  Token2[Token2["SuperKeyword"] = 104] = "SuperKeyword";
+  Token2[Token2["KeyofKeyword"] = 105] = "KeyofKeyword";
+  Token2[Token2["WithKeyword"] = 106] = "WithKeyword";
+  Token2[Token2["ImplementsKeyword"] = 107] = "ImplementsKeyword";
+  Token2[Token2["ImplKeyword"] = 108] = "ImplKeyword";
+  Token2[Token2["SatisfiesKeyword"] = 109] = "SatisfiesKeyword";
+  Token2[Token2["FlagKeyword"] = 110] = "FlagKeyword";
+  Token2[Token2["AutoKeyword"] = 111] = "AutoKeyword";
+  Token2[Token2["PartialKeyword"] = 112] = "PartialKeyword";
+  Token2[Token2["PrivateKeyword"] = 113] = "PrivateKeyword";
+  Token2[Token2["PublicKeyword"] = 114] = "PublicKeyword";
+  Token2[Token2["ProtectedKeyword"] = 115] = "ProtectedKeyword";
   Token2[Token2["SealedKeyword"] = 116] = "SealedKeyword";
   Token2[Token2["LocalKeyword"] = 117] = "LocalKeyword";
   Token2[Token2["AsyncKeyword"] = 118] = "AsyncKeyword";
@@ -3248,6 +3325,7 @@ var Keywords = /* @__PURE__ */ new Map([
   ["never", Token.NeverKeyword],
   ["unknown", Token.UnknownKeyword],
   ["extern", Token.ExternKeyword],
+  ["internal", Token.InternalKeyword],
   // Reserved keywords
   ["statemachine", Token.StatemachineKeyword],
   ["macro", Token.MacroKeyword],
@@ -3284,7 +3362,6 @@ var Keywords = /* @__PURE__ */ new Map([
   ["private", Token.PrivateKeyword],
   ["public", Token.PublicKeyword],
   ["protected", Token.ProtectedKeyword],
-  ["internal", Token.InternalKeyword],
   ["sealed", Token.SealedKeyword],
   ["local", Token.LocalKeyword],
   ["async", Token.AsyncKeyword]
@@ -3323,7 +3400,6 @@ var ReservedKeywords = /* @__PURE__ */ new Map([
   ["private", Token.PrivateKeyword],
   ["public", Token.PublicKeyword],
   ["protected", Token.ProtectedKeyword],
-  ["internal", Token.InternalKeyword],
   ["sealed", Token.SealedKeyword],
   ["local", Token.LocalKeyword],
   ["async", Token.AsyncKeyword]
@@ -3353,6 +3429,9 @@ function isReservedKeyword(token) {
 function isPunctuation(token) {
   return token >= Token.__StartPunctuation && token < Token.__EndPunctuation;
 }
+function isModifier(token) {
+  return token >= Token.__StartModifierKeyword && token < Token.__EndModifierKeyword;
+}
 function isStatementKeyword(token) {
   return token >= Token.__StartStatementKeyword && token < Token.__EndStatementKeyword;
 }
@@ -4052,14 +4131,13 @@ function createScanner(source, diagnosticHandler) {
   }
   function scanIdentifierOrKeyword() {
     let count = 0;
-    let ch = input.charCodeAt(position);
     while (true) {
       position++;
       count++;
       if (eof()) {
         break;
       }
-      ch = input.charCodeAt(position);
+      const ch = input.charCodeAt(position);
       if (count < 12 && isLowercaseAsciiLetter(ch)) {
         continue;
       }
@@ -4405,35 +4483,6 @@ function createParser(code, options = {}) {
           reportInvalidDecorators(decorators, "import statement");
           item = parseImportStatement();
           break;
-        case Token.ModelKeyword:
-          item = parseModelStatement(pos, decorators);
-          break;
-        case Token.ScalarKeyword:
-          item = parseScalarStatement(pos, decorators);
-          break;
-        case Token.NamespaceKeyword:
-          item = parseNamespaceStatement(pos, decorators, docs, directives);
-          break;
-        case Token.InterfaceKeyword:
-          item = parseInterfaceStatement(pos, decorators);
-          break;
-        case Token.UnionKeyword:
-          item = parseUnionStatement(pos, decorators);
-          break;
-        case Token.OpKeyword:
-          item = parseOperationStatement(pos, decorators);
-          break;
-        case Token.EnumKeyword:
-          item = parseEnumStatement(pos, decorators);
-          break;
-        case Token.AliasKeyword:
-          reportInvalidDecorators(decorators, "alias statement");
-          item = parseAliasStatement(pos);
-          break;
-        case Token.ConstKeyword:
-          reportInvalidDecorators(decorators, "const statement");
-          item = parseConstStatement(pos);
-          break;
         case Token.UsingKeyword:
           reportInvalidDecorators(decorators, "using statement");
           item = parseUsingStatement(pos);
@@ -4443,10 +4492,20 @@ function createParser(code, options = {}) {
           item = parseEmptyStatement(pos);
           break;
         // Start of declaration with modifiers
+        case Token.NamespaceKeyword:
+        case Token.ModelKeyword:
+        case Token.ScalarKeyword:
+        case Token.InterfaceKeyword:
+        case Token.UnionKeyword:
+        case Token.OpKeyword:
+        case Token.EnumKeyword:
+        case Token.AliasKeyword:
+        case Token.ConstKeyword:
         case Token.ExternKeyword:
+        case Token.InternalKeyword:
         case Token.FnKeyword:
         case Token.DecKeyword:
-          item = parseDeclaration(pos);
+          item = parseDeclaration(pos, decorators, docs, directives);
           break;
         default:
           item = parseInvalidStatement(pos, decorators);
@@ -4493,47 +4552,24 @@ function createParser(code, options = {}) {
           item = parseImportStatement();
           error({ code: "import-first", messageId: "topLevel", target: item });
           break;
-        case Token.ModelKeyword:
-          item = parseModelStatement(pos, decorators);
+        case Token.UsingKeyword:
+          reportInvalidDecorators(decorators, "using statement");
+          item = parseUsingStatement(pos);
           break;
+        case Token.ModelKeyword:
         case Token.ScalarKeyword:
-          item = parseScalarStatement(pos, decorators);
-          break;
         case Token.NamespaceKeyword:
-          const ns = parseNamespaceStatement(pos, decorators, docs, directives);
-          if (isBlocklessNamespace(ns)) {
-            error({ code: "blockless-namespace-first", messageId: "topLevel", target: ns });
-          }
-          item = ns;
-          break;
         case Token.InterfaceKeyword:
-          item = parseInterfaceStatement(pos, decorators);
-          break;
         case Token.UnionKeyword:
-          item = parseUnionStatement(pos, decorators);
-          break;
         case Token.OpKeyword:
-          item = parseOperationStatement(pos, decorators);
-          break;
         case Token.EnumKeyword:
-          item = parseEnumStatement(pos, decorators);
-          break;
         case Token.AliasKeyword:
-          reportInvalidDecorators(decorators, "alias statement");
-          item = parseAliasStatement(pos);
-          break;
         case Token.ConstKeyword:
-          reportInvalidDecorators(decorators, "const statement");
-          item = parseConstStatement(pos);
-          break;
-        case Token.UsingKeyword:
-          reportInvalidDecorators(decorators, "using statement");
-          item = parseUsingStatement(pos);
-          break;
         case Token.ExternKeyword:
+        case Token.InternalKeyword:
         case Token.FnKeyword:
         case Token.DecKeyword:
-          item = parseDeclaration(pos);
+          item = parseDeclaration(pos, decorators, docs, directives);
           break;
         case Token.EndOfFile:
           parseExpected(Token.CloseBrace);
@@ -4546,6 +4582,9 @@ function createParser(code, options = {}) {
           item = parseInvalidStatement(pos, decorators);
           break;
       }
+      if (isBlocklessNamespace(item)) {
+        error({ code: "blockless-namespace-first", messageId: "topLevel", target: item });
+      }
       mutate(item).directives = directives;
       if (tok !== Token.NamespaceKeyword) {
         mutate(item).docs = docs;
@@ -4568,7 +4607,7 @@ function createParser(code, options = {}) {
     }
     return directives;
   }
-  function parseNamespaceStatement(pos, decorators, docs, directives) {
+  function parseNamespaceStatement(pos, decorators, modifiers, docs, directives) {
     parseExpected(Token.NamespaceKeyword);
     let currentName = parseIdentifierOrMemberExpression();
     const nsSegments = [];
@@ -4591,6 +4630,8 @@ function createParser(code, options = {}) {
       locals: void 0,
       statements,
       directives,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
     for (let i = 1; i < nsSegments.length; i++) {
@@ -4601,12 +4642,14 @@ function createParser(code, options = {}) {
         id: nsSegments[i],
         statements: outerNs,
         locals: void 0,
+        modifiers: [],
+        modifierFlags: 0,
         ...finishNode(pos)
       };
     }
     return outerNs;
   }
-  function parseInterfaceStatement(pos, decorators) {
+  function parseInterfaceStatement(pos, decorators, modifiers) {
     parseExpected(Token.InterfaceKeyword);
     const id = parseIdentifier();
     const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -4618,7 +4661,13 @@ function createParser(code, options = {}) {
       error({ code: "token-expected", format: { token: "'extends' or '{'" } });
       nextToken();
     }
-    const { items: operations, range: bodyRange } = parseList(ListKind.InterfaceMembers, (pos2, decorators2) => parseOperationStatement(pos2, decorators2, true));
+    const { items: operations, range: bodyRange } = parseList(ListKind.InterfaceMembers, (pos2, decorators2) => parseOperationStatement(
+      pos2,
+      decorators2,
+      /* modifiers */
+      void 0,
+      true
+    ));
     return {
       kind: SyntaxKind.InterfaceStatement,
       id,
@@ -4628,6 +4677,8 @@ function createParser(code, options = {}) {
       bodyRange,
       extends: extendList.items,
       decorators,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
   }
@@ -4645,7 +4696,7 @@ function createParser(code, options = {}) {
     }
     return detail;
   }
-  function parseUnionStatement(pos, decorators) {
+  function parseUnionStatement(pos, decorators, modifiers) {
     parseExpected(Token.UnionKeyword);
     const id = parseIdentifier();
     const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -4656,6 +4707,8 @@ function createParser(code, options = {}) {
       templateParameters,
       templateParametersRange,
       decorators,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       options: options2,
       ...finishNode(pos)
     };
@@ -4663,10 +4716,14 @@ function createParser(code, options = {}) {
   function parseIdOrValueForVariant() {
     const nextToken2 = token();
     let id;
-    if (isReservedKeyword(nextToken2)) {
+    if (isReservedKeyword(nextToken2) || isModifier(nextToken2)) {
       id = parseIdentifier({ allowReservedIdentifier: true });
       if (token() !== Token.Colon) {
-        error({ code: "reserved-identifier", messageId: "future", format: { name: id.sv } });
+        if (isReservedKeyword(nextToken2)) {
+          error({ code: "reserved-identifier", messageId: "future", format: { name: id.sv } });
+        } else {
+          error({ code: "reserved-identifier" });
+        }
       }
       return {
         kind: SyntaxKind.TypeReference,
@@ -4725,10 +4782,13 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
-  function parseOperationStatement(pos, decorators, inInterface) {
+  function parseOperationStatement(pos, decorators, _modifiers, inInterface) {
+    let modifiers;
     if (inInterface) {
+      modifiers = parseModifiers();
       parseOptional(Token.OpKeyword);
     } else {
+      modifiers = _modifiers;
       parseExpected(Token.OpKeyword);
     }
     const id = parseIdentifier();
@@ -4765,6 +4825,8 @@ function createParser(code, options = {}) {
       templateParametersRange,
       signature,
       decorators,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
   }
@@ -4779,7 +4841,7 @@ function createParser(code, options = {}) {
     };
     return parameters;
   }
-  function parseModelStatement(pos, decorators) {
+  function parseModelStatement(pos, decorators, modifiers) {
     parseExpected(Token.ModelKeyword);
     const id = parseIdentifier();
     const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -4807,6 +4869,8 @@ function createParser(code, options = {}) {
       decorators,
       properties: propDetail.items,
       bodyRange: propDetail.range,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
   }
@@ -4827,7 +4891,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 +4909,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();
@@ -4930,7 +4994,7 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
-  function parseScalarStatement(pos, decorators) {
+  function parseScalarStatement(pos, decorators, modifiers) {
     parseExpected(Token.ScalarKeyword);
     const id = parseIdentifier();
     const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -4945,6 +5009,8 @@ function createParser(code, options = {}) {
       members,
       bodyRange,
       decorators,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
   }
@@ -4974,7 +5040,7 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
-  function parseEnumStatement(pos, decorators) {
+  function parseEnumStatement(pos, decorators, modifiers) {
     parseExpected(Token.EnumKeyword);
     const id = parseIdentifier();
     const { items: members } = parseList(ListKind.EnumMembers, parseEnumMemberOrSpread);
@@ -4982,6 +5048,8 @@ function createParser(code, options = {}) {
       kind: SyntaxKind.EnumStatement,
       id,
       decorators,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       members,
       ...finishNode(pos)
     };
@@ -5024,7 +5092,7 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
-  function parseAliasStatement(pos) {
+  function parseAliasStatement(pos, modifiers) {
     parseExpected(Token.AliasKeyword);
     const id = parseIdentifier();
     const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -5037,10 +5105,12 @@ function createParser(code, options = {}) {
       templateParameters,
       templateParametersRange,
       value,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
   }
-  function parseConstStatement(pos) {
+  function parseConstStatement(pos, modifiers) {
     parseExpected(Token.ConstKeyword);
     const id = parseIdentifier();
     const type = parseOptionalTypeAnnotation();
@@ -5052,6 +5122,8 @@ function createParser(code, options = {}) {
       id,
       value,
       type,
+      modifiers,
+      modifierFlags: modifiersToFlags(modifiers),
       ...finishNode(pos)
     };
   }
@@ -5076,6 +5148,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 +5246,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 +5484,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:
@@ -5439,6 +5534,14 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
+  function parseInternalKeyword() {
+    const pos = tokenPos();
+    parseExpected(Token.InternalKeyword);
+    return {
+      kind: SyntaxKind.InternalKeyword,
+      ...finishNode(pos)
+    };
+  }
   function parseVoidKeyword() {
     const pos = tokenPos();
     parseExpected(Token.VoidKeyword);
@@ -5468,7 +5571,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();
@@ -5623,8 +5726,10 @@ function createParser(code, options = {}) {
   }
   function parseIdentifier(options2) {
     if (isKeyword(token())) {
-      error({ code: "reserved-identifier" });
-      return createMissingIdentifier();
+      if (!(isModifier(token()) && options2?.allowReservedIdentifier)) {
+        error({ code: "reserved-identifier" });
+        return createMissingIdentifier();
+      }
     } else if (isReservedKeyword(token())) {
       if (!options2?.allowReservedIdentifier) {
         error({ code: "reserved-identifier", messageId: "future", format: { name: tokenValue() } });
@@ -5642,9 +5747,29 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
-  function parseDeclaration(pos) {
+  function parseDeclaration(pos, decorators, docs, directives) {
     const modifiers = parseModifiers();
     switch (token()) {
+      case Token.ModelKeyword:
+        return parseModelStatement(pos, decorators, modifiers);
+      case Token.ScalarKeyword:
+        return parseScalarStatement(pos, decorators, modifiers);
+      case Token.NamespaceKeyword:
+        return parseNamespaceStatement(pos, decorators, modifiers, docs, directives);
+      case Token.InterfaceKeyword:
+        return parseInterfaceStatement(pos, decorators, modifiers);
+      case Token.UnionKeyword:
+        return parseUnionStatement(pos, decorators, modifiers);
+      case Token.OpKeyword:
+        return parseOperationStatement(pos, decorators, modifiers);
+      case Token.EnumKeyword:
+        return parseEnumStatement(pos, decorators, modifiers);
+      case Token.AliasKeyword:
+        reportInvalidDecorators(decorators, "alias statement");
+        return parseAliasStatement(pos, modifiers);
+      case Token.ConstKeyword:
+        reportInvalidDecorators(decorators, "const statement");
+        return parseConstStatement(pos, modifiers);
       case Token.DecKeyword:
         return parseDecoratorDeclarationStatement(pos, modifiers);
       case Token.FnKeyword:
@@ -5664,6 +5789,8 @@ function createParser(code, options = {}) {
     switch (token()) {
       case Token.ExternKeyword:
         return parseExternKeyword();
+      case Token.InternalKeyword:
+        return parseInternalKeyword();
       default:
         return void 0;
     }
@@ -5706,7 +5833,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 +5873,7 @@ function createParser(code, options = {}) {
     const optional = parseOptional(Token.Question);
     let type;
     if (parseOptional(Token.Colon)) {
-      type = parseMixedParameterConstraint();
+      type = parseMixedConstraint();
     }
     return {
       kind: SyntaxKind.FunctionParameter,
@@ -5757,17 +5884,6 @@ function createParser(code, options = {}) {
       ...finishNode(pos)
     };
   }
-  function modifiersToFlags(modifiers) {
-    let flags = 0;
-    for (const modifier of modifiers) {
-      switch (modifier.kind) {
-        case SyntaxKind.ExternKeyword:
-          flags |= 2;
-          break;
-      }
-    }
-    return flags;
-  }
   function parseRange(mode, range, callback) {
     const savedMode = currentMode;
     const result = scanner.scanRange(range, () => {
@@ -6301,15 +6417,15 @@ function visitChildren(node, cb) {
     case SyntaxKind.ImportStatement:
       return visitNode(cb, node.path);
     case SyntaxKind.OperationStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitNode(cb, node.signature);
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitNode(cb, node.signature);
     case SyntaxKind.OperationSignatureDeclaration:
       return visitNode(cb, node.parameters) || visitNode(cb, node.returnType);
     case SyntaxKind.OperationSignatureReference:
       return visitNode(cb, node.baseOperation);
     case SyntaxKind.NamespaceStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || (isArray(node.statements) ? visitEach(cb, node.statements) : visitNode(cb, node.statements));
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || (isArray(node.statements) ? visitEach(cb, node.statements) : visitNode(cb, node.statements));
     case SyntaxKind.InterfaceStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitEach(cb, node.extends) || visitEach(cb, node.operations);
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitEach(cb, node.extends) || visitEach(cb, node.operations);
     case SyntaxKind.UsingStatement:
       return visitNode(cb, node.name);
     case SyntaxKind.IntersectionExpression:
@@ -6323,29 +6439,31 @@ function visitChildren(node, cb) {
     case SyntaxKind.ModelSpreadProperty:
       return visitNode(cb, node.target);
     case SyntaxKind.ModelStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitNode(cb, node.extends) || visitNode(cb, node.is) || visitEach(cb, node.properties);
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitNode(cb, node.extends) || visitNode(cb, node.is) || visitEach(cb, node.properties);
     case SyntaxKind.ScalarStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitEach(cb, node.members) || visitNode(cb, node.extends);
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitEach(cb, node.members) || visitNode(cb, node.extends);
     case SyntaxKind.ScalarConstructor:
       return visitNode(cb, node.id) || visitEach(cb, node.parameters);
     case SyntaxKind.UnionStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitEach(cb, node.options);
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitEach(cb, node.options);
     case SyntaxKind.UnionVariant:
       return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitNode(cb, node.value);
     case SyntaxKind.EnumStatement:
-      return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.members);
+      return visitEach(cb, node.modifiers) || visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.members);
     case SyntaxKind.EnumMember:
       return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitNode(cb, node.value);
     case SyntaxKind.EnumSpreadMember:
       return visitNode(cb, node.target);
     case SyntaxKind.AliasStatement:
-      return visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitNode(cb, node.value);
+      return visitEach(cb, node.modifiers) || visitNode(cb, node.id) || visitEach(cb, node.templateParameters) || visitNode(cb, node.value);
     case SyntaxKind.ConstStatement:
-      return visitNode(cb, node.id) || visitNode(cb, node.value) || visitNode(cb, node.type);
+      return visitEach(cb, node.modifiers) || visitNode(cb, node.id) || visitNode(cb, node.value) || visitNode(cb, node.type);
     case SyntaxKind.DecoratorDeclarationStatement:
       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:
@@ -6399,6 +6517,7 @@ function visitChildren(node, cb) {
     case SyntaxKind.VoidKeyword:
     case SyntaxKind.NeverKeyword:
     case SyntaxKind.ExternKeyword:
+    case SyntaxKind.InternalKeyword:
     case SyntaxKind.UnknownKeyword:
     case SyntaxKind.JsSourceFile:
     case SyntaxKind.JsNamespaceDeclaration:
@@ -6680,10 +6799,14 @@ 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:
       return "extern";
+    case SyntaxKind.InternalKeyword:
+      return "internal";
     case SyntaxKind.VoidKeyword:
       return "void";
     case SyntaxKind.NeverKeyword:
@@ -6743,13 +6866,29 @@ function printTypeSpecScript(path, options, print) {
 function printAliasStatement(path, options, print) {
   const id = path.call(print, "id");
   const template = printTemplateParameters(path, options, print, "templateParameters");
-  return ["alias ", id, template, " = ", path.call(print, "value"), ";"];
+  return [
+    printModifiers(path, options, print),
+    "alias ",
+    id,
+    template,
+    " = ",
+    path.call(print, "value"),
+    ";"
+  ];
 }
 function printConstStatement(path, options, print) {
   const node = path.node;
   const id = path.call(print, "id");
   const type = node.type ? [": ", path.call(print, "type")] : "";
-  return ["const ", id, type, " = ", path.call(print, "value"), ";"];
+  return [
+    printModifiers(path, options, print),
+    "const ",
+    id,
+    type,
+    " = ",
+    path.call(print, "value"),
+    ";"
+  ];
 }
 function printCallExpression(path, options, print) {
   const args = printCallLikeArgs(path, options, print);
@@ -6907,7 +7046,14 @@ function printDirectiveArgs(path, options, print) {
 function printEnumStatement(path, options, print) {
   const { decorators } = printDecorators(path, options, print, { tryInline: false });
   const id = path.call(print, "id");
-  return [decorators, "enum ", id, " ", printEnumBlock(path, options, print)];
+  return [
+    decorators,
+    printModifiers(path, options, print),
+    "enum ",
+    id,
+    " ",
+    printEnumBlock(path, options, print)
+  ];
 }
 function printEnumBlock(path, options, print) {
   const node = path.node;
@@ -6933,7 +7079,15 @@ function printUnionStatement(path, options, print) {
   const id = path.call(print, "id");
   const { decorators } = printDecorators(path, options, print, { tryInline: false });
   const generic = printTemplateParameters(path, options, print, "templateParameters");
-  return [decorators, "union ", id, generic, " ", printUnionVariantsBlock(path, options, print)];
+  return [
+    decorators,
+    printModifiers(path, options, print),
+    "union ",
+    id,
+    generic,
+    " ",
+    printUnionVariantsBlock(path, options, print)
+  ];
 }
 function printUnionVariantsBlock(path, options, print) {
   const node = path.node;
@@ -6957,6 +7111,7 @@ function printInterfaceStatement(path, options, print) {
   const extendList = printInterfaceExtends(path, options, print);
   return [
     decorators,
+    printModifiers(path, options, print),
     "interface ",
     id,
     generic,
@@ -7112,6 +7267,7 @@ function printModelStatement(path, options, print) {
   const body = shouldPrintBody ? [" ", printModelPropertiesBlock(path, options, print)] : ";";
   return [
     printDecorators(path, options, print, { tryInline: false }).decorators,
+    printModifiers(path, options, print),
     "model ",
     id,
     generic,
@@ -7218,6 +7374,7 @@ function printScalarStatement(path, options, print) {
   const members = shouldPrintBody ? [" ", printScalarBody(path, options, print)] : ";";
   return [
     printDecorators(path, options, print, { tryInline: false }).decorators,
+    printModifiers(path, options, print),
     "scalar ",
     id,
     template,
@@ -7274,6 +7431,7 @@ function printOperationStatement(path, options, print) {
   });
   return [
     decorators,
+    printModifiers(path, options, print),
     inInterface ? "" : "op ",
     path.call(print, "id"),
     templateParams,
@@ -7391,6 +7549,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");
@@ -7405,7 +7574,7 @@ function printFunctionParameterDeclaration(path, options, print) {
 }
 function printModifiers(path, options, print) {
   const node = path.node;
-  if (node.modifiers.length === 0) {
+  if (node.modifiers === void 0 || node.modifiers.length === 0) {
     return "";
   }
   return path.map((x) => [print(x), " "], "modifiers");