@typespec/prettier-plugin-typespec 0.67.0-dev.1 → 0.67.0

package/dist/index.js

@@ -1,220 +1,5 @@
 'use strict';
 
-function createSourceFile(text, path) {
-    let lineStarts = undefined;
-    return {
-        text,
-        path,
-        getLineStarts,
-        getLineAndCharacterOfPosition,
-    };
-    function getLineStarts() {
-        return (lineStarts = lineStarts ?? scanLineStarts(text));
-    }
-    function getLineAndCharacterOfPosition(position) {
-        const starts = getLineStarts();
-        let line = binarySearch(starts, position);
-        // When binarySearch returns < 0 indicating that the value was not found, it
-        // returns the bitwise complement of the index where the value would need to
-        // be inserted to keep the array sorted. So flipping the bits back to this
-        // positive index tells us what the line number would be if we were to
-        // create a new line starting at the given position, and subtracting 1 from
-        // that therefore gives us the line number we're after.
-        if (line < 0) {
-            line = ~line - 1;
-        }
-        return {
-            line,
-            character: position - starts[line],
-        };
-    }
-}
-function scanLineStarts(text) {
-    const starts = [];
-    let start = 0;
-    let pos = 0;
-    while (pos < text.length) {
-        const ch = text.charCodeAt(pos);
-        pos++;
-        switch (ch) {
-            case 13 /* CharCode.CarriageReturn */:
-                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
-                    pos++;
-                }
-            // fallthrough
-            case 10 /* CharCode.LineFeed */:
-                starts.push(start);
-                start = pos;
-                break;
-        }
-    }
-    starts.push(start);
-    return starts;
-}
-/**
- * Search sorted array of numbers for the given value. If found, return index
- * in array where value was found. If not found, return a negative number that
- * is the bitwise complement of the index where value would need to be inserted
- * to keep the array sorted.
- */
-function binarySearch(array, value) {
-    let low = 0;
-    let high = array.length - 1;
-    while (low <= high) {
-        const middle = low + ((high - low) >> 1);
-        const v = array[middle];
-        if (v < value) {
-            low = middle + 1;
-        }
-        else if (v > value) {
-            high = middle - 1;
-        }
-        else {
-            return middle;
-        }
-    }
-    return ~low;
-}
-
-var ResolutionResultFlags;
-(function (ResolutionResultFlags) {
-    ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
-    ResolutionResultFlags[ResolutionResultFlags["Resolved"] = 2] = "Resolved";
-    ResolutionResultFlags[ResolutionResultFlags["Unknown"] = 4] = "Unknown";
-    ResolutionResultFlags[ResolutionResultFlags["Ambiguous"] = 8] = "Ambiguous";
-    ResolutionResultFlags[ResolutionResultFlags["NotFound"] = 16] = "NotFound";
-    ResolutionResultFlags[ResolutionResultFlags["ResolutionFailed"] = 28] = "ResolutionFailed";
-})(ResolutionResultFlags || (ResolutionResultFlags = {}));
-/**
- * AST types
- */
-var SyntaxKind;
-(function (SyntaxKind) {
-    SyntaxKind[SyntaxKind["TypeSpecScript"] = 0] = "TypeSpecScript";
-    SyntaxKind[SyntaxKind["JsSourceFile"] = 1] = "JsSourceFile";
-    SyntaxKind[SyntaxKind["ImportStatement"] = 2] = "ImportStatement";
-    SyntaxKind[SyntaxKind["Identifier"] = 3] = "Identifier";
-    SyntaxKind[SyntaxKind["AugmentDecoratorStatement"] = 4] = "AugmentDecoratorStatement";
-    SyntaxKind[SyntaxKind["DecoratorExpression"] = 5] = "DecoratorExpression";
-    SyntaxKind[SyntaxKind["DirectiveExpression"] = 6] = "DirectiveExpression";
-    SyntaxKind[SyntaxKind["MemberExpression"] = 7] = "MemberExpression";
-    SyntaxKind[SyntaxKind["NamespaceStatement"] = 8] = "NamespaceStatement";
-    SyntaxKind[SyntaxKind["UsingStatement"] = 9] = "UsingStatement";
-    SyntaxKind[SyntaxKind["OperationStatement"] = 10] = "OperationStatement";
-    SyntaxKind[SyntaxKind["OperationSignatureDeclaration"] = 11] = "OperationSignatureDeclaration";
-    SyntaxKind[SyntaxKind["OperationSignatureReference"] = 12] = "OperationSignatureReference";
-    SyntaxKind[SyntaxKind["ModelStatement"] = 13] = "ModelStatement";
-    SyntaxKind[SyntaxKind["ModelExpression"] = 14] = "ModelExpression";
-    SyntaxKind[SyntaxKind["ModelProperty"] = 15] = "ModelProperty";
-    SyntaxKind[SyntaxKind["ModelSpreadProperty"] = 16] = "ModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ScalarStatement"] = 17] = "ScalarStatement";
-    SyntaxKind[SyntaxKind["InterfaceStatement"] = 18] = "InterfaceStatement";
-    SyntaxKind[SyntaxKind["UnionStatement"] = 19] = "UnionStatement";
-    SyntaxKind[SyntaxKind["UnionVariant"] = 20] = "UnionVariant";
-    SyntaxKind[SyntaxKind["EnumStatement"] = 21] = "EnumStatement";
-    SyntaxKind[SyntaxKind["EnumMember"] = 22] = "EnumMember";
-    SyntaxKind[SyntaxKind["EnumSpreadMember"] = 23] = "EnumSpreadMember";
-    SyntaxKind[SyntaxKind["AliasStatement"] = 24] = "AliasStatement";
-    SyntaxKind[SyntaxKind["DecoratorDeclarationStatement"] = 25] = "DecoratorDeclarationStatement";
-    SyntaxKind[SyntaxKind["FunctionDeclarationStatement"] = 26] = "FunctionDeclarationStatement";
-    SyntaxKind[SyntaxKind["FunctionParameter"] = 27] = "FunctionParameter";
-    SyntaxKind[SyntaxKind["UnionExpression"] = 28] = "UnionExpression";
-    SyntaxKind[SyntaxKind["IntersectionExpression"] = 29] = "IntersectionExpression";
-    SyntaxKind[SyntaxKind["TupleExpression"] = 30] = "TupleExpression";
-    SyntaxKind[SyntaxKind["ArrayExpression"] = 31] = "ArrayExpression";
-    SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
-    SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
-    SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
-    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
-    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
-    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
-    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
-    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
-    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
-    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
-    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
-    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
-    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
-    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
-    SyntaxKind[SyntaxKind["ProjectionReference"] = 46] = "ProjectionReference";
-    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 47] = "TemplateParameterDeclaration";
-    SyntaxKind[SyntaxKind["EmptyStatement"] = 48] = "EmptyStatement";
-    SyntaxKind[SyntaxKind["InvalidStatement"] = 49] = "InvalidStatement";
-    SyntaxKind[SyntaxKind["LineComment"] = 50] = "LineComment";
-    SyntaxKind[SyntaxKind["BlockComment"] = 51] = "BlockComment";
-    SyntaxKind[SyntaxKind["Doc"] = 52] = "Doc";
-    SyntaxKind[SyntaxKind["DocText"] = 53] = "DocText";
-    SyntaxKind[SyntaxKind["DocParamTag"] = 54] = "DocParamTag";
-    SyntaxKind[SyntaxKind["DocPropTag"] = 55] = "DocPropTag";
-    SyntaxKind[SyntaxKind["DocReturnsTag"] = 56] = "DocReturnsTag";
-    SyntaxKind[SyntaxKind["DocErrorsTag"] = 57] = "DocErrorsTag";
-    SyntaxKind[SyntaxKind["DocTemplateTag"] = 58] = "DocTemplateTag";
-    SyntaxKind[SyntaxKind["DocUnknownTag"] = 59] = "DocUnknownTag";
-    SyntaxKind[SyntaxKind["Projection"] = 60] = "Projection";
-    SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 61] = "ProjectionParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 62] = "ProjectionModelSelector";
-    SyntaxKind[SyntaxKind["ProjectionModelPropertySelector"] = 63] = "ProjectionModelPropertySelector";
-    SyntaxKind[SyntaxKind["ProjectionScalarSelector"] = 64] = "ProjectionScalarSelector";
-    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 65] = "ProjectionOperationSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 66] = "ProjectionUnionSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 67] = "ProjectionUnionVariantSelector";
-    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 68] = "ProjectionInterfaceSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 69] = "ProjectionEnumSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 70] = "ProjectionEnumMemberSelector";
-    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 71] = "ProjectionExpressionStatement";
-    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 72] = "ProjectionIfExpression";
-    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 73] = "ProjectionBlockExpression";
-    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 74] = "ProjectionMemberExpression";
-    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 75] = "ProjectionLogicalExpression";
-    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 76] = "ProjectionEqualityExpression";
-    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 77] = "ProjectionUnaryExpression";
-    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 78] = "ProjectionRelationalExpression";
-    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 79] = "ProjectionArithmeticExpression";
-    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 80] = "ProjectionCallExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 81] = "ProjectionLambdaExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 82] = "ProjectionLambdaParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 83] = "ProjectionModelExpression";
-    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 84] = "ProjectionModelProperty";
-    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 85] = "ProjectionModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 86] = "ProjectionSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 87] = "ProjectionTupleExpression";
-    SyntaxKind[SyntaxKind["ProjectionStatement"] = 88] = "ProjectionStatement";
-    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 89] = "ProjectionDecoratorReferenceExpression";
-    SyntaxKind[SyntaxKind["Return"] = 90] = "Return";
-    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 91] = "JsNamespaceDeclaration";
-    SyntaxKind[SyntaxKind["TemplateArgument"] = 92] = "TemplateArgument";
-    SyntaxKind[SyntaxKind["TypeOfExpression"] = 93] = "TypeOfExpression";
-    SyntaxKind[SyntaxKind["ObjectLiteral"] = 94] = "ObjectLiteral";
-    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 95] = "ObjectLiteralProperty";
-    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 96] = "ObjectLiteralSpreadProperty";
-    SyntaxKind[SyntaxKind["ArrayLiteral"] = 97] = "ArrayLiteral";
-    SyntaxKind[SyntaxKind["ConstStatement"] = 98] = "ConstStatement";
-    SyntaxKind[SyntaxKind["CallExpression"] = 99] = "CallExpression";
-    SyntaxKind[SyntaxKind["ScalarConstructor"] = 100] = "ScalarConstructor";
-})(SyntaxKind || (SyntaxKind = {}));
-var IdentifierKind;
-(function (IdentifierKind) {
-    IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
-    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["ModelExpressionProperty"] = 6] = "ModelExpressionProperty";
-    IdentifierKind[IdentifierKind["ModelStatementProperty"] = 7] = "ModelStatementProperty";
-    IdentifierKind[IdentifierKind["ObjectLiteralProperty"] = 8] = "ObjectLiteralProperty";
-    IdentifierKind[IdentifierKind["Other"] = 9] = "Other";
-})(IdentifierKind || (IdentifierKind = {}));
-/** Used to explicitly specify that a diagnostic has no target. */
-const NoTarget = Symbol.for("NoTarget");
-var ListenerFlow;
-(function (ListenerFlow) {
-    /**
-     * Do not navigate any containing or referenced type.
-     */
-    ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
-})(ListenerFlow || (ListenerFlow = {}));
-
 /**
  * A specially typed version of `Array.isArray` to work around [this issue](https://github.com/microsoft/TypeScript/issues/17002).
  */
@@ -426,7 +211,6 @@ const diagnostics = {
             unexpected: paramMessage `Unexpected token ${"token"}`,
             numericOrStringLiteral: "Expected numeric or string literal.",
             identifier: "Identifier expected.",
-            projectionDirection: "from or to expected.",
             expression: "Expression expected.",
             statement: "Statement expected.",
             property: "Property expected.",
@@ -465,6 +249,7 @@ const diagnostics = {
         severity: "error",
         messages: {
             default: "Keyword cannot be used as identifier.",
+            future: paramMessage `${"name"} is a reserved keyword`,
         },
     },
     "invalid-directive-location": {
@@ -479,15 +264,6 @@ const diagnostics = {
             default: paramMessage `Cannot decorate ${"nodeName"}.`,
         },
     },
-    "invalid-projection": {
-        severity: "error",
-        messages: {
-            default: "Invalid projection",
-            wrongType: "Non-projection can't be used to project",
-            noTo: "Projection missing to projection",
-            projectionError: paramMessage `An error occurred when projecting this type: ${"message"}`,
-        },
-    },
     "default-required": {
         severity: "error",
         messages: {
@@ -682,7 +458,8 @@ const diagnostics = {
         messages: {
             default: paramMessage `${"name"} refers to a type, but is being used as a value here.`,
             model: paramMessage `${"name"} refers to a model type, but is being used as a value here. Use #{} to create an object value.`,
-            tuple: paramMessage `${"name"} refers to a tuple type, but is being used as a value here. Use #[] to create an array 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.`,
         },
     },
@@ -827,6 +604,12 @@ const diagnostics = {
             default: "A function declaration must be prefixed with the 'extern' modifier.",
         },
     },
+    "function-unsupported": {
+        severity: "error",
+        messages: {
+            default: "Function are currently not supported.",
+        },
+    },
     "missing-implementation": {
         severity: "error",
         messages: {
@@ -1328,56 +1111,240 @@ const diagnostics = {
 };
 const { createDiagnostic} = createDiagnosticCreator(diagnostics);
 
-function getSourceLocation(target, options = {}) {
-    if (target === NoTarget || target === undefined) {
-        return undefined;
-    }
-    if ("file" in target) {
-        return target;
+function createSourceFile(text, path) {
+    let lineStarts = undefined;
+    return {
+        text,
+        path,
+        getLineStarts,
+        getLineAndCharacterOfPosition,
+    };
+    function getLineStarts() {
+        return (lineStarts = lineStarts ?? scanLineStarts(text));
     }
-    if (!("kind" in target) && !("entityKind" in target)) {
-        // TemplateInstanceTarget
-        if (!("declarations" in target)) {
-            return getSourceLocationOfNode(target.node, options);
-        }
-        // symbol
-        if (target.flags & 32768 /* SymbolFlags.Using */) {
-            target = target.symbolSource;
-        }
-        if (!target.declarations[0]) {
-            return createSyntheticSourceLocation();
+    function getLineAndCharacterOfPosition(position) {
+        const starts = getLineStarts();
+        let line = binarySearch(starts, position);
+        // When binarySearch returns < 0 indicating that the value was not found, it
+        // returns the bitwise complement of the index where the value would need to
+        // be inserted to keep the array sorted. So flipping the bits back to this
+        // positive index tells us what the line number would be if we were to
+        // create a new line starting at the given position, and subtracting 1 from
+        // that therefore gives us the line number we're after.
+        if (line < 0) {
+            line = ~line - 1;
         }
-        return getSourceLocationOfNode(target.declarations[0], options);
-    }
-    else if ("kind" in target && typeof target.kind === "number") {
-        // node
-        return getSourceLocationOfNode(target, options);
+        return {
+            line,
+            character: position - starts[line],
+        };
     }
-    else {
-        // type
-        const targetNode = target.node;
-        if (targetNode) {
-            return getSourceLocationOfNode(targetNode, options);
+}
+function scanLineStarts(text) {
+    const starts = [];
+    let start = 0;
+    let pos = 0;
+    while (pos < text.length) {
+        const ch = text.charCodeAt(pos);
+        pos++;
+        switch (ch) {
+            case 13 /* CharCode.CarriageReturn */:
+                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
+                    pos++;
+                }
+            // fallthrough
+            case 10 /* CharCode.LineFeed */:
+                starts.push(start);
+                start = pos;
+                break;
         }
-        return createSyntheticSourceLocation();
     }
+    starts.push(start);
+    return starts;
 }
-function createSyntheticSourceLocation(loc = "<unknown location>") {
-    return {
-        file: createSourceFile("", loc),
-        pos: 0,
-        end: 0,
-        isSynthetic: true,
-    };
-}
-function getSourceLocationOfNode(node, options) {
-    let root = node;
-    while (root.parent !== undefined) {
-        root = root.parent;
-    }
-    if (root.kind !== SyntaxKind.TypeSpecScript && root.kind !== SyntaxKind.JsSourceFile) {
-        return createSyntheticSourceLocation(node.flags & 8 /* NodeFlags.Synthetic */
-            ? undefined
+/**
+ * Search sorted array of numbers for the given value. If found, return index
+ * in array where value was found. If not found, return a negative number that
+ * is the bitwise complement of the index where value would need to be inserted
+ * to keep the array sorted.
+ */
+function binarySearch(array, value) {
+    let low = 0;
+    let high = array.length - 1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const v = array[middle];
+        if (v < value) {
+            low = middle + 1;
+        }
+        else if (v > value) {
+            high = middle - 1;
+        }
+        else {
+            return middle;
+        }
+    }
+    return ~low;
+}
+
+var ResolutionResultFlags;
+(function (ResolutionResultFlags) {
+    ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
+    ResolutionResultFlags[ResolutionResultFlags["Resolved"] = 2] = "Resolved";
+    ResolutionResultFlags[ResolutionResultFlags["Unknown"] = 4] = "Unknown";
+    ResolutionResultFlags[ResolutionResultFlags["Ambiguous"] = 8] = "Ambiguous";
+    ResolutionResultFlags[ResolutionResultFlags["NotFound"] = 16] = "NotFound";
+    ResolutionResultFlags[ResolutionResultFlags["ResolutionFailed"] = 28] = "ResolutionFailed";
+})(ResolutionResultFlags || (ResolutionResultFlags = {}));
+/**
+ * AST types
+ */
+var SyntaxKind;
+(function (SyntaxKind) {
+    SyntaxKind[SyntaxKind["TypeSpecScript"] = 0] = "TypeSpecScript";
+    SyntaxKind[SyntaxKind["JsSourceFile"] = 1] = "JsSourceFile";
+    SyntaxKind[SyntaxKind["ImportStatement"] = 2] = "ImportStatement";
+    SyntaxKind[SyntaxKind["Identifier"] = 3] = "Identifier";
+    SyntaxKind[SyntaxKind["AugmentDecoratorStatement"] = 4] = "AugmentDecoratorStatement";
+    SyntaxKind[SyntaxKind["DecoratorExpression"] = 5] = "DecoratorExpression";
+    SyntaxKind[SyntaxKind["DirectiveExpression"] = 6] = "DirectiveExpression";
+    SyntaxKind[SyntaxKind["MemberExpression"] = 7] = "MemberExpression";
+    SyntaxKind[SyntaxKind["NamespaceStatement"] = 8] = "NamespaceStatement";
+    SyntaxKind[SyntaxKind["UsingStatement"] = 9] = "UsingStatement";
+    SyntaxKind[SyntaxKind["OperationStatement"] = 10] = "OperationStatement";
+    SyntaxKind[SyntaxKind["OperationSignatureDeclaration"] = 11] = "OperationSignatureDeclaration";
+    SyntaxKind[SyntaxKind["OperationSignatureReference"] = 12] = "OperationSignatureReference";
+    SyntaxKind[SyntaxKind["ModelStatement"] = 13] = "ModelStatement";
+    SyntaxKind[SyntaxKind["ModelExpression"] = 14] = "ModelExpression";
+    SyntaxKind[SyntaxKind["ModelProperty"] = 15] = "ModelProperty";
+    SyntaxKind[SyntaxKind["ModelSpreadProperty"] = 16] = "ModelSpreadProperty";
+    SyntaxKind[SyntaxKind["ScalarStatement"] = 17] = "ScalarStatement";
+    SyntaxKind[SyntaxKind["InterfaceStatement"] = 18] = "InterfaceStatement";
+    SyntaxKind[SyntaxKind["UnionStatement"] = 19] = "UnionStatement";
+    SyntaxKind[SyntaxKind["UnionVariant"] = 20] = "UnionVariant";
+    SyntaxKind[SyntaxKind["EnumStatement"] = 21] = "EnumStatement";
+    SyntaxKind[SyntaxKind["EnumMember"] = 22] = "EnumMember";
+    SyntaxKind[SyntaxKind["EnumSpreadMember"] = 23] = "EnumSpreadMember";
+    SyntaxKind[SyntaxKind["AliasStatement"] = 24] = "AliasStatement";
+    SyntaxKind[SyntaxKind["DecoratorDeclarationStatement"] = 25] = "DecoratorDeclarationStatement";
+    SyntaxKind[SyntaxKind["FunctionDeclarationStatement"] = 26] = "FunctionDeclarationStatement";
+    SyntaxKind[SyntaxKind["FunctionParameter"] = 27] = "FunctionParameter";
+    SyntaxKind[SyntaxKind["UnionExpression"] = 28] = "UnionExpression";
+    SyntaxKind[SyntaxKind["IntersectionExpression"] = 29] = "IntersectionExpression";
+    SyntaxKind[SyntaxKind["TupleExpression"] = 30] = "TupleExpression";
+    SyntaxKind[SyntaxKind["ArrayExpression"] = 31] = "ArrayExpression";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
+    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
+    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
+    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
+    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
+    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
+    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
+    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
+    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
+    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
+    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
+    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
+    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 46] = "TemplateParameterDeclaration";
+    SyntaxKind[SyntaxKind["EmptyStatement"] = 47] = "EmptyStatement";
+    SyntaxKind[SyntaxKind["InvalidStatement"] = 48] = "InvalidStatement";
+    SyntaxKind[SyntaxKind["LineComment"] = 49] = "LineComment";
+    SyntaxKind[SyntaxKind["BlockComment"] = 50] = "BlockComment";
+    SyntaxKind[SyntaxKind["Doc"] = 51] = "Doc";
+    SyntaxKind[SyntaxKind["DocText"] = 52] = "DocText";
+    SyntaxKind[SyntaxKind["DocParamTag"] = 53] = "DocParamTag";
+    SyntaxKind[SyntaxKind["DocPropTag"] = 54] = "DocPropTag";
+    SyntaxKind[SyntaxKind["DocReturnsTag"] = 55] = "DocReturnsTag";
+    SyntaxKind[SyntaxKind["DocErrorsTag"] = 56] = "DocErrorsTag";
+    SyntaxKind[SyntaxKind["DocTemplateTag"] = 57] = "DocTemplateTag";
+    SyntaxKind[SyntaxKind["DocUnknownTag"] = 58] = "DocUnknownTag";
+    SyntaxKind[SyntaxKind["Return"] = 59] = "Return";
+    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 60] = "JsNamespaceDeclaration";
+    SyntaxKind[SyntaxKind["TemplateArgument"] = 61] = "TemplateArgument";
+    SyntaxKind[SyntaxKind["TypeOfExpression"] = 62] = "TypeOfExpression";
+    SyntaxKind[SyntaxKind["ObjectLiteral"] = 63] = "ObjectLiteral";
+    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 64] = "ObjectLiteralProperty";
+    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 65] = "ObjectLiteralSpreadProperty";
+    SyntaxKind[SyntaxKind["ArrayLiteral"] = 66] = "ArrayLiteral";
+    SyntaxKind[SyntaxKind["ConstStatement"] = 67] = "ConstStatement";
+    SyntaxKind[SyntaxKind["CallExpression"] = 68] = "CallExpression";
+    SyntaxKind[SyntaxKind["ScalarConstructor"] = 69] = "ScalarConstructor";
+})(SyntaxKind || (SyntaxKind = {}));
+var IdentifierKind;
+(function (IdentifierKind) {
+    IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
+    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["ModelExpressionProperty"] = 6] = "ModelExpressionProperty";
+    IdentifierKind[IdentifierKind["ModelStatementProperty"] = 7] = "ModelStatementProperty";
+    IdentifierKind[IdentifierKind["ObjectLiteralProperty"] = 8] = "ObjectLiteralProperty";
+    IdentifierKind[IdentifierKind["Other"] = 9] = "Other";
+})(IdentifierKind || (IdentifierKind = {}));
+/** Used to explicitly specify that a diagnostic has no target. */
+const NoTarget = Symbol.for("NoTarget");
+var ListenerFlow;
+(function (ListenerFlow) {
+    /**
+     * Do not navigate any containing or referenced type.
+     */
+    ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
+})(ListenerFlow || (ListenerFlow = {}));
+
+function getSourceLocation(target, options = {}) {
+    if (target === NoTarget || target === undefined) {
+        return undefined;
+    }
+    if ("file" in target) {
+        return target;
+    }
+    if (!("kind" in target) && !("entityKind" in target)) {
+        // TemplateInstanceTarget
+        if (!("declarations" in target)) {
+            return getSourceLocationOfNode(target.node, options);
+        }
+        // symbol
+        if (target.flags & 8192 /* SymbolFlags.Using */) {
+            target = target.symbolSource;
+        }
+        if (!target.declarations[0]) {
+            return createSyntheticSourceLocation();
+        }
+        return getSourceLocationOfNode(target.declarations[0], options);
+    }
+    else if ("kind" in target && typeof target.kind === "number") {
+        // node
+        return getSourceLocationOfNode(target, options);
+    }
+    else {
+        // type
+        const targetNode = target.node;
+        if (targetNode) {
+            return getSourceLocationOfNode(targetNode, options);
+        }
+        return createSyntheticSourceLocation();
+    }
+}
+function createSyntheticSourceLocation(loc = "<unknown location>") {
+    return {
+        file: createSourceFile("", loc),
+        pos: 0,
+        end: 0,
+        isSynthetic: true,
+    };
+}
+function getSourceLocationOfNode(node, options) {
+    let root = node;
+    while (root.parent !== undefined) {
+        root = root.parent;
+    }
+    if (root.kind !== SyntaxKind.TypeSpecScript && root.kind !== SyntaxKind.JsSourceFile) {
+        return createSyntheticSourceLocation(node.flags & 8 /* NodeFlags.Synthetic */
+            ? undefined
             : "<unknown location - cannot obtain source location of unbound node - file bug at https://github.com/microsoft/typespec>");
     }
     if (options.locateId && "id" in node && node.id !== undefined) {
@@ -2408,7 +2375,46 @@ var Token;
     // Add new non-statement keyword above
     /** @internal */ Token[Token["__EndKeyword"] = 80] = "__EndKeyword";
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__Count"] = 80] = "__Count";
+    /** @internal */ Token[Token["__StartReservedKeyword"] = 80] = "__StartReservedKeyword";
+    ///////////////////////////////////////////////////////////////
+    // List of keywords that have special meaning in the language but are reserved for future use
+    Token[Token["StatemachineKeyword"] = 80] = "StatemachineKeyword";
+    Token[Token["MacroKeyword"] = 81] = "MacroKeyword";
+    Token[Token["PackageKeyword"] = 82] = "PackageKeyword";
+    Token[Token["MetadataKeyword"] = 83] = "MetadataKeyword";
+    Token[Token["EnvKeyword"] = 84] = "EnvKeyword";
+    Token[Token["ArgKeyword"] = 85] = "ArgKeyword";
+    Token[Token["DeclareKeyword"] = 86] = "DeclareKeyword";
+    Token[Token["ArrayKeyword"] = 87] = "ArrayKeyword";
+    Token[Token["StructKeyword"] = 88] = "StructKeyword";
+    Token[Token["RecordKeyword"] = 89] = "RecordKeyword";
+    Token[Token["ModuleKeyword"] = 90] = "ModuleKeyword";
+    Token[Token["ModKeyword"] = 91] = "ModKeyword";
+    Token[Token["PubKeyword"] = 92] = "PubKeyword";
+    Token[Token["SubKeyword"] = 93] = "SubKeyword";
+    Token[Token["TypeRefKeyword"] = 94] = "TypeRefKeyword";
+    Token[Token["TraitKeyword"] = 95] = "TraitKeyword";
+    Token[Token["ThisKeyword"] = 96] = "ThisKeyword";
+    Token[Token["SelfKeyword"] = 97] = "SelfKeyword";
+    Token[Token["SuperKeyword"] = 98] = "SuperKeyword";
+    Token[Token["KeyofKeyword"] = 99] = "KeyofKeyword";
+    Token[Token["WithKeyword"] = 100] = "WithKeyword";
+    Token[Token["ImplementsKeyword"] = 101] = "ImplementsKeyword";
+    Token[Token["ImplKeyword"] = 102] = "ImplKeyword";
+    Token[Token["SatisfiesKeyword"] = 103] = "SatisfiesKeyword";
+    Token[Token["FlagKeyword"] = 104] = "FlagKeyword";
+    Token[Token["AutoKeyword"] = 105] = "AutoKeyword";
+    Token[Token["PartialKeyword"] = 106] = "PartialKeyword";
+    Token[Token["PrivateKeyword"] = 107] = "PrivateKeyword";
+    Token[Token["PublicKeyword"] = 108] = "PublicKeyword";
+    Token[Token["ProtectedKeyword"] = 109] = "ProtectedKeyword";
+    Token[Token["InternalKeyword"] = 110] = "InternalKeyword";
+    Token[Token["SealedKeyword"] = 111] = "SealedKeyword";
+    Token[Token["LocalKeyword"] = 112] = "LocalKeyword";
+    Token[Token["AsyncKeyword"] = 113] = "AsyncKeyword";
+    /** @internal */ Token[Token["__EndReservedKeyword"] = 114] = "__EndReservedKeyword";
+    ///////////////////////////////////////////////////////////////
+    /** @internal */ Token[Token["__Count"] = 114] = "__Count";
 })(Token || (Token = {}));
 /** @internal */
 const TokenDisplay = getTokenDisplayTable([
@@ -2492,6 +2498,41 @@ const TokenDisplay = getTokenDisplayTable([
     [Token.NeverKeyword, "'never'"],
     [Token.UnknownKeyword, "'unknown'"],
     [Token.ExternKeyword, "'extern'"],
+    // Reserved keywords
+    [Token.StatemachineKeyword, "'statemachine'"],
+    [Token.MacroKeyword, "'macro'"],
+    [Token.PackageKeyword, "'package'"],
+    [Token.MetadataKeyword, "'metadata'"],
+    [Token.EnvKeyword, "'env'"],
+    [Token.ArgKeyword, "'arg'"],
+    [Token.DeclareKeyword, "'declare'"],
+    [Token.ArrayKeyword, "'array'"],
+    [Token.StructKeyword, "'struct'"],
+    [Token.RecordKeyword, "'record'"],
+    [Token.ModuleKeyword, "'module'"],
+    [Token.ModKeyword, "'mod'"],
+    [Token.PubKeyword, "'pub'"],
+    [Token.SubKeyword, "'sub'"],
+    [Token.TypeRefKeyword, "'typeref'"],
+    [Token.TraitKeyword, "'trait'"],
+    [Token.ThisKeyword, "'this'"],
+    [Token.SelfKeyword, "'self'"],
+    [Token.SuperKeyword, "'super'"],
+    [Token.KeyofKeyword, "'keyof'"],
+    [Token.WithKeyword, "'with'"],
+    [Token.ImplementsKeyword, "'implements'"],
+    [Token.ImplKeyword, "'impl'"],
+    [Token.SatisfiesKeyword, "'satisfies'"],
+    [Token.FlagKeyword, "'flag'"],
+    [Token.AutoKeyword, "'auto'"],
+    [Token.PartialKeyword, "'partial'"],
+    [Token.PrivateKeyword, "'private'"],
+    [Token.PublicKeyword, "'public'"],
+    [Token.ProtectedKeyword, "'protected'"],
+    [Token.InternalKeyword, "'internal'"],
+    [Token.SealedKeyword, "'sealed'"],
+    [Token.LocalKeyword, "'local'"],
+    [Token.AsyncKeyword, "'async'"],
 ]);
 /** @internal */
 const Keywords = new Map([
@@ -2523,6 +2564,75 @@ const Keywords = new Map([
     ["never", Token.NeverKeyword],
     ["unknown", Token.UnknownKeyword],
     ["extern", Token.ExternKeyword],
+    // Reserved keywords
+    ["statemachine", Token.StatemachineKeyword],
+    ["macro", Token.MacroKeyword],
+    ["package", Token.PackageKeyword],
+    ["metadata", Token.MetadataKeyword],
+    ["env", Token.EnvKeyword],
+    ["arg", Token.ArgKeyword],
+    ["declare", Token.DeclareKeyword],
+    ["array", Token.ArrayKeyword],
+    ["struct", Token.StructKeyword],
+    ["record", Token.RecordKeyword],
+    ["module", Token.ModuleKeyword],
+    ["mod", Token.ModKeyword],
+    ["pub", Token.PubKeyword],
+    ["sub", Token.SubKeyword],
+    ["typeref", Token.TypeRefKeyword],
+    ["trait", Token.TraitKeyword],
+    ["this", Token.ThisKeyword],
+    ["self", Token.SelfKeyword],
+    ["super", Token.SuperKeyword],
+    ["keyof", Token.KeyofKeyword],
+    ["with", Token.WithKeyword],
+    ["implements", Token.ImplementsKeyword],
+    ["impl", Token.ImplKeyword],
+    ["satisfies", Token.SatisfiesKeyword],
+    ["flag", Token.FlagKeyword],
+    ["auto", Token.AutoKeyword],
+    ["partial", Token.PartialKeyword],
+    ["private", Token.PrivateKeyword],
+    ["public", Token.PublicKeyword],
+    ["protected", Token.ProtectedKeyword],
+    ["internal", Token.InternalKeyword],
+    ["sealed", Token.SealedKeyword],
+    ["local", Token.LocalKeyword],
+    ["async", Token.AsyncKeyword],
+]);
+/** @internal */
+const ReservedKeywords = new Map([
+    // Reserved keywords
+    ["statemachine", Token.StatemachineKeyword],
+    ["macro", Token.MacroKeyword],
+    ["package", Token.PackageKeyword],
+    ["metadata", Token.MetadataKeyword],
+    ["env", Token.EnvKeyword],
+    ["arg", Token.ArgKeyword],
+    ["declare", Token.DeclareKeyword],
+    ["array", Token.ArrayKeyword],
+    ["struct", Token.StructKeyword],
+    ["record", Token.RecordKeyword],
+    ["module", Token.ModuleKeyword],
+    ["trait", Token.TraitKeyword],
+    ["this", Token.ThisKeyword],
+    ["self", Token.SelfKeyword],
+    ["super", Token.SuperKeyword],
+    ["keyof", Token.KeyofKeyword],
+    ["with", Token.WithKeyword],
+    ["implements", Token.ImplementsKeyword],
+    ["impl", Token.ImplKeyword],
+    ["satisfies", Token.SatisfiesKeyword],
+    ["flag", Token.FlagKeyword],
+    ["auto", Token.AutoKeyword],
+    ["partial", Token.PartialKeyword],
+    ["private", Token.PrivateKeyword],
+    ["public", Token.PublicKeyword],
+    ["protected", Token.ProtectedKeyword],
+    ["internal", Token.InternalKeyword],
+    ["sealed", Token.SealedKeyword],
+    ["local", Token.LocalKeyword],
+    ["async", Token.AsyncKeyword],
 ]);
 var TokenFlags;
 (function (TokenFlags) {
@@ -2543,6 +2653,10 @@ function isComment(token) {
 function isKeyword(token) {
     return token >= Token.__StartKeyword && token < Token.__EndKeyword;
 }
+/** If is a keyword with no actual use right now but will be in the future. */
+function isReservedKeyword(token) {
+    return token >= Token.__StartReservedKeyword && token < Token.__EndReservedKeyword;
+}
 function isPunctuation(token) {
     return token >= Token.__StartPunctuation && token < Token.__EndPunctuation;
 }
@@ -3294,7 +3408,7 @@ function createScanner(source, diagnosticHandler) {
                 break;
             }
             ch = input.charCodeAt(position);
-            if (count < 10 /* KeywordLimit.MaxLength */ && isLowercaseAsciiLetter(ch)) {
+            if (count < 12 /* KeywordLimit.MaxLength */ && isLowercaseAsciiLetter(ch)) {
                 continue;
             }
             if (isAsciiIdentifierContinue(ch)) {
@@ -3308,7 +3422,7 @@ function createScanner(source, diagnosticHandler) {
             }
             break;
         }
-        if (count >= 2 /* KeywordLimit.MinLength */ && count <= 10 /* KeywordLimit.MaxLength */) {
+        if (count >= 2 /* KeywordLimit.MinLength */ && count <= 12 /* KeywordLimit.MaxLength */) {
             const keyword = Keywords.get(getTokenText());
             if (keyword) {
                 return (token = keyword);
@@ -3452,8 +3566,9 @@ function getTokenDisplayTable(entries) {
  * printIdentifier("foo bar") // `foo bar`
  * ```
  */
-function printIdentifier$1(sv) {
-    if (needBacktick(sv)) {
+function printIdentifier$1(sv, 
+/** @internal */ context = "disallow-reserved") {
+    if (needBacktick(sv, context)) {
         const escapedString = sv
             .replace(/\\/g, "\\\\")
             .replace(/\n/g, "\\n")
@@ -3466,10 +3581,13 @@ function printIdentifier$1(sv) {
         return sv;
     }
 }
-function needBacktick(sv) {
+function needBacktick(sv, context) {
     if (sv.length === 0) {
         return false;
     }
+    if (context === "allow-reserved" && ReservedKeywords.has(sv)) {
+        return false;
+    }
     if (Keywords.has(sv)) {
         return true;
     }
@@ -3630,18 +3748,6 @@ var ListKind;
         close: Token.CloseParen,
         invalidAnnotationTarget: "expression",
     };
-    ListKind.ProjectionExpression = {
-        ...ExpresionsBase,
-        allowEmpty: true,
-        open: Token.OpenParen,
-        close: Token.CloseParen,
-    };
-    ListKind.ProjectionParameter = {
-        ...ExpresionsBase,
-        allowEmpty: true,
-        open: Token.OpenParen,
-        close: Token.CloseParen,
-    };
 })(ListKind || (ListKind = {}));
 function parse$1(code, options = {}) {
     const parser = createParser(code, options);
@@ -3769,10 +3875,6 @@ function createParser(code, options = {}) {
                     reportInvalidDecorators(decorators, "using statement");
                     item = parseUsingStatement(pos);
                     break;
-                case Token.ProjectionKeyword:
-                    reportInvalidDecorators(decorators, "projection statement");
-                    item = parseProjectionStatement(pos);
-                    break;
                 case Token.Semicolon:
                     reportInvalidDecorators(decorators, "empty statement");
                     item = parseEmptyStatement(pos);
@@ -3873,10 +3975,6 @@ function createParser(code, options = {}) {
                 case Token.DecKeyword:
                     item = parseDeclaration(pos);
                     break;
-                case Token.ProjectionKeyword:
-                    reportInvalidDecorators(decorators, "project statement");
-                    item = parseProjectionStatement(pos);
-                    break;
                 case Token.EndOfFile:
                     parseExpected(Token.CloseBrace);
                     return stmts;
@@ -4003,8 +4101,28 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseIdOrValueForVariant() {
+        const nextToken = token();
+        let id;
+        if (isReservedKeyword(nextToken)) {
+            id = parseIdentifier({ allowReservedIdentifier: true });
+            // If the next token is not a colon this means we tried to use the reserved keyword as a type reference
+            if (token() !== Token.Colon) {
+                error({ code: "reserved-identifier", messageId: "future", format: { name: id.sv } });
+            }
+            return {
+                kind: SyntaxKind.TypeReference,
+                target: id,
+                arguments: [],
+                ...finishNode(id.pos),
+            };
+        }
+        else {
+            return parseExpression();
+        }
+    }
     function parseUnionVariant(pos, decorators) {
-        const idOrExpr = parseExpression();
+        const idOrExpr = parseIdOrValueForVariant();
         if (parseOptional(Token.Colon)) {
             let id = undefined;
             if (idOrExpr.kind !== SyntaxKind.TypeReference &&
@@ -4047,7 +4165,7 @@ function createParser(code, options = {}) {
     }
     function parseUsingStatement(pos) {
         parseExpected(Token.UsingKeyword);
-        const name = parseIdentifierOrMemberExpression(undefined, true);
+        const name = parseIdentifierOrMemberExpression();
         parseExpected(Token.Semicolon);
         return {
             kind: SyntaxKind.UsingStatement,
@@ -4227,6 +4345,7 @@ function createParser(code, options = {}) {
         const id = parseIdentifier({
             message: "property",
             allowStringLiteral: true,
+            allowReservedIdentifier: true,
         });
         const optional = parseOptional(Token.Question);
         parseExpected(Token.Colon);
@@ -4262,6 +4381,7 @@ function createParser(code, options = {}) {
     function parseObjectLiteralProperty(pos) {
         const id = parseIdentifier({
             message: "property",
+            allowReservedIdentifier: true,
         });
         parseExpected(Token.Colon);
         const value = parseExpression();
@@ -4348,6 +4468,7 @@ function createParser(code, options = {}) {
         const id = parseIdentifier({
             message: "enumMember",
             allowStringLiteral: true,
+            allowReservedIdentifier: true,
         });
         let value;
         if (parseOptional(Token.Colon)) {
@@ -4515,12 +4636,18 @@ function createParser(code, options = {}) {
     }
     function parseReferenceExpression(message) {
         const pos = tokenPos();
-        const target = parseIdentifierOrMemberExpression(message);
+        const target = parseIdentifierOrMemberExpression({
+            message,
+            allowReservedIdentifierInMember: true,
+        });
         return parseReferenceExpressionInternal(target, pos);
     }
     function parseCallOrReferenceExpression(message) {
         const pos = tokenPos();
-        const target = parseIdentifierOrMemberExpression(message);
+        const target = parseIdentifierOrMemberExpression({
+            message,
+            allowReservedIdentifierInMember: true,
+        });
         if (token() === Token.OpenParen) {
             const { items: args } = parseList(ListKind.FunctionArguments, parseExpression);
             return {
@@ -4583,7 +4710,7 @@ function createParser(code, options = {}) {
         // identifier. We want to parse `@ model Foo` as invalid decorator
         // `@<missing identifier>` applied to `model Foo`, and not as `@model`
         // applied to invalid statement `Foo`.
-        const target = parseIdentifierOrMemberExpression(undefined, false);
+        const target = parseIdentifierOrMemberExpression({ allowReservedIdentifierInMember: true });
         const { items: args } = parseOptionalList(ListKind.DecoratorArguments, parseExpression);
         if (args.length === 0) {
             error({ code: "augment-decorator-target" });
@@ -4639,7 +4766,10 @@ function createParser(code, options = {}) {
         // identifier. We want to parse `@ model Foo` as invalid decorator
         // `@<missing identifier>` applied to `model Foo`, and not as `@model`
         // applied to invalid statement `Foo`.
-        const target = parseIdentifierOrMemberExpression(undefined, false);
+        const target = parseIdentifierOrMemberExpression({
+            allowReservedIdentifier: true,
+            allowReservedIdentifierInMember: true,
+        });
         const { items: args } = parseOptionalList(ListKind.DecoratorArguments, parseExpression);
         return {
             kind: SyntaxKind.DecoratorExpression,
@@ -4700,11 +4830,11 @@ function createParser(code, options = {}) {
                 return undefined;
         }
     }
-    function parseIdentifierOrMemberExpression(message, recoverFromKeyword = true) {
+    function parseIdentifierOrMemberExpression(options) {
         const pos = tokenPos();
         let base = parseIdentifier({
-            message,
-            recoverFromKeyword,
+            message: options?.message,
+            allowReservedIdentifier: options?.allowReservedIdentifier,
         });
         while (token() !== Token.EndOfFile) {
             if (parseOptional(Token.Dot)) {
@@ -4717,7 +4847,7 @@ function createParser(code, options = {}) {
                     // `@Outer.model` applied to invalid statement `M {}` instead of
                     // having incomplete decorator `@Outer.` applied to `model M {}`.
                     id: parseIdentifier({
-                        recoverFromKeyword: false,
+                        allowReservedIdentifier: options?.allowReservedIdentifierInMember,
                     }),
                     selector: ".",
                     ...finishNode(pos),
@@ -4960,731 +5090,173 @@ function createParser(code, options = {}) {
         const value = Number(valueAsString);
         parseExpected(Token.NumericLiteral);
         return {
-            kind: SyntaxKind.NumericLiteral,
-            value,
-            valueAsString,
-            ...finishNode(pos),
-        };
-    }
-    function parseBooleanLiteral() {
-        const pos = tokenPos();
-        const token = parseExpectedOneOf(Token.TrueKeyword, Token.FalseKeyword);
-        const value = token === Token.TrueKeyword;
-        return {
-            kind: SyntaxKind.BooleanLiteral,
-            value,
-            ...finishNode(pos),
-        };
-    }
-    function parseIdentifier(options) {
-        if (options?.recoverFromKeyword !== false && isKeyword(token())) {
-            error({ code: "reserved-identifier" });
-        }
-        else if (token() !== Token.Identifier &&
-            (!options?.allowStringLiteral || token() !== Token.StringLiteral)) {
-            // Error recovery: when we fail to parse an identifier or expression,
-            // we insert a synthesized identifier with a unique name.
-            error({ code: "token-expected", messageId: options?.message ?? "identifier" });
-            return createMissingIdentifier();
-        }
-        const pos = tokenPos();
-        const sv = tokenValue();
-        nextToken();
-        return {
-            kind: SyntaxKind.Identifier,
-            sv,
-            ...finishNode(pos),
-        };
-    }
-    function parseDeclaration(pos) {
-        const modifiers = parseModifiers();
-        switch (token()) {
-            case Token.DecKeyword:
-                return parseDecoratorDeclarationStatement(pos, modifiers);
-            case Token.FnKeyword:
-                return parseFunctionDeclarationStatement(pos, modifiers);
-        }
-        return parseInvalidStatement(pos, []);
-    }
-    function parseModifiers() {
-        const modifiers = [];
-        let modifier;
-        while ((modifier = parseModifier())) {
-            modifiers.push(modifier);
-        }
-        return modifiers;
-    }
-    function parseModifier() {
-        switch (token()) {
-            case Token.ExternKeyword:
-                return parseExternKeyword();
-            default:
-                return undefined;
-        }
-    }
-    function parseDecoratorDeclarationStatement(pos, modifiers) {
-        const modifierFlags = modifiersToFlags(modifiers);
-        parseExpected(Token.DecKeyword);
-        const id = parseIdentifier();
-        const allParamListDetail = parseFunctionParameters();
-        let [target, ...parameters] = allParamListDetail.items;
-        if (target === undefined) {
-            error({ code: "decorator-decl-target", target: { pos, end: previousTokenEnd } });
-            target = {
-                kind: SyntaxKind.FunctionParameter,
-                id: createMissingIdentifier(),
-                type: createMissingTypeReference(),
-                optional: false,
-                rest: false,
-                ...finishNode(pos),
-            };
-        }
-        if (target.optional) {
-            error({ code: "decorator-decl-target", messageId: "required" });
-        }
-        parseExpected(Token.Semicolon);
-        return {
-            kind: SyntaxKind.DecoratorDeclarationStatement,
-            modifiers,
-            modifierFlags,
-            id,
-            target,
-            parameters,
-            ...finishNode(pos),
-        };
-    }
-    function parseFunctionDeclarationStatement(pos, modifiers) {
-        const modifierFlags = modifiersToFlags(modifiers);
-        parseExpected(Token.FnKeyword);
-        const id = parseIdentifier();
-        const { items: parameters } = parseFunctionParameters();
-        let returnType;
-        if (parseOptional(Token.Colon)) {
-            returnType = parseExpression();
-        }
-        parseExpected(Token.Semicolon);
-        return {
-            kind: SyntaxKind.FunctionDeclarationStatement,
-            modifiers,
-            modifierFlags,
-            id,
-            parameters,
-            returnType,
-            ...finishNode(pos),
-        };
-    }
-    function parseFunctionParameters() {
-        const parameters = parseList(ListKind.FunctionParameters, parseFunctionParameter);
-        let foundOptional = false;
-        for (const [index, item] of parameters.items.entries()) {
-            if (!item.optional && foundOptional) {
-                error({ code: "required-parameter-first", target: item });
-                continue;
-            }
-            if (item.optional) {
-                foundOptional = true;
-            }
-            if (item.rest && item.optional) {
-                error({ code: "rest-parameter-required", target: item });
-            }
-            if (item.rest && index !== parameters.items.length - 1) {
-                error({ code: "rest-parameter-last", target: item });
-            }
-        }
-        return parameters;
-    }
-    function parseFunctionParameter() {
-        const pos = tokenPos();
-        const rest = parseOptional(Token.Ellipsis);
-        const id = parseIdentifier({ message: "property" });
-        const optional = parseOptional(Token.Question);
-        let type;
-        if (parseOptional(Token.Colon)) {
-            type = parseMixedParameterConstraint();
-        }
-        return {
-            kind: SyntaxKind.FunctionParameter,
-            id,
-            type,
-            optional,
-            rest,
-            ...finishNode(pos),
-        };
-    }
-    function modifiersToFlags(modifiers) {
-        let flags = 0 /* ModifierFlags.None */;
-        for (const modifier of modifiers) {
-            switch (modifier.kind) {
-                case SyntaxKind.ExternKeyword:
-                    flags |= 2 /* ModifierFlags.Extern */;
-                    break;
-            }
-        }
-        return flags;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    function parseProjectionStatement(pos) {
-        parseExpected(Token.ProjectionKeyword);
-        const selector = parseProjectionSelector();
-        parseExpected(Token.Hash);
-        const id = parseIdentifier();
-        parseExpected(Token.OpenBrace);
-        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);
-                }
-            }
-            // NOTE: Don't drop projections with error in direction definition from the AST.
-            projections.push(projection);
-        }
-        parseExpected(Token.CloseBrace);
-        return {
-            kind: SyntaxKind.ProjectionStatement,
-            selector,
-            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();
-        let directionId = parseIdentifier({ message: "projectionDirection" });
-        let direction;
-        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 = "<error>";
-        }
-        else if (isPre) {
-            direction = directionId.sv === "to" ? "pre_to" : "pre_from";
-        }
-        else {
-            direction = directionId.sv;
-        }
-        let parameters;
-        if (token() === Token.OpenParen) {
-            parameters = parseList(ListKind.ProjectionParameter, parseProjectionParameter).items;
-        }
-        else {
-            parameters = [];
-        }
-        parseExpected(Token.OpenBrace);
-        const body = parseProjectionStatementList();
-        parseExpected(Token.CloseBrace);
-        return {
-            kind: SyntaxKind.Projection,
-            body,
-            direction,
-            directionId,
-            modifierIds,
-            parameters,
-            ...finishNode(pos),
-        };
-    }
-    function parseProjectionParameter() {
-        const pos = tokenPos();
-        const id = parseIdentifier();
-        return {
-            kind: SyntaxKind.ProjectionParameterDeclaration,
-            id,
-            ...finishNode(pos),
-        };
-    }
-    function parseProjectionStatementList() {
-        const stmts = [];
-        while (token() !== Token.CloseBrace) {
-            const startPos = tokenPos();
-            if (token() === Token.EndOfFile) {
-                error({ code: "token-expected", messageId: "default", format: { token: "}" } });
-                break;
-            }
-            const expr = parseProjectionExpressionStatement();
-            stmts.push(expr);
-            if (tokenPos() === startPos) {
-                // we didn't manage to parse anything, so break out
-                // and we'll report errors elsewhere.
-                break;
-            }
-        }
-        return stmts;
-    }
-    function parseProjectionExpressionStatement() {
-        const pos = tokenPos();
-        const expr = parseProjectionExpression();
-        parseExpected(Token.Semicolon);
-        return {
-            kind: SyntaxKind.ProjectionExpressionStatement,
-            expr,
-            ...finishNode(pos),
-        };
-    }
-    function parseProjectionExpression() {
-        return parseProjectionReturnExpressionOrHigher();
-    }
-    function parseProjectionReturnExpressionOrHigher() {
-        if (token() === Token.ReturnKeyword) {
-            const pos = tokenPos();
-            parseExpected(Token.ReturnKeyword);
-            return {
-                kind: SyntaxKind.Return,
-                value: parseProjectionExpression(),
-                ...finishNode(pos),
-            };
-        }
-        return parseProjectionLogicalOrExpressionOrHigher();
-    }
-    function parseProjectionLogicalOrExpressionOrHigher() {
-        let expr = parseProjectionLogicalAndExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            if (parseOptional(Token.BarBar)) {
-                expr = {
-                    kind: SyntaxKind.ProjectionLogicalExpression,
-                    op: "||",
-                    left: expr,
-                    right: parseProjectionLogicalAndExpressionOrHigher(),
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionLogicalAndExpressionOrHigher() {
-        let expr = parseProjectionEqualityExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            if (parseOptional(Token.AmpsersandAmpersand)) {
-                expr = {
-                    kind: SyntaxKind.ProjectionLogicalExpression,
-                    op: "&&",
-                    left: expr,
-                    right: parseProjectionEqualityExpressionOrHigher(),
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionEqualityExpressionOrHigher() {
-        let expr = parseProjectionRelationalExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            const tok = token();
-            if (tok === Token.EqualsEquals || tok === Token.ExclamationEquals) {
-                const op = tokenValue();
-                nextToken();
-                expr = {
-                    kind: SyntaxKind.ProjectionEqualityExpression,
-                    op,
-                    left: expr,
-                    right: parseProjectionRelationalExpressionOrHigher(),
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionRelationalExpressionOrHigher() {
-        let expr = parseProjectionAdditiveExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            const tok = token();
-            if (tok === Token.LessThan ||
-                tok === Token.LessThanEquals ||
-                tok === Token.GreaterThan ||
-                tok === Token.GreaterThanEquals) {
-                const op = tokenValue();
-                nextToken();
-                expr = {
-                    kind: SyntaxKind.ProjectionRelationalExpression,
-                    op,
-                    left: expr,
-                    right: parseProjectionAdditiveExpressionOrHigher(),
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionAdditiveExpressionOrHigher() {
-        let expr = parseProjectionMultiplicativeExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            const tok = token();
-            if (tok === Token.Plus || tok === Token.Hyphen) {
-                const op = tokenValue();
-                nextToken();
-                expr = {
-                    kind: SyntaxKind.ProjectionArithmeticExpression,
-                    op,
-                    left: expr,
-                    right: parseProjectionMultiplicativeExpressionOrHigher(),
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionMultiplicativeExpressionOrHigher() {
-        let expr = parseProjectionUnaryExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            const tok = token();
-            if (tok === Token.ForwardSlash || tok === Token.Star) {
-                const op = tokenValue();
-                nextToken();
-                expr = {
-                    kind: SyntaxKind.ProjectionArithmeticExpression,
-                    op,
-                    left: expr,
-                    right: parseProjectionUnaryExpressionOrHigher(),
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionUnaryExpressionOrHigher() {
-        if (token() === Token.Exclamation) {
-            const pos = tokenPos();
-            nextToken();
-            return {
-                kind: SyntaxKind.ProjectionUnaryExpression,
-                op: "!",
-                target: parseProjectionUnaryExpressionOrHigher(),
-                ...finishNode(pos),
-            };
-        }
-        return parseProjectionCallExpressionOrHigher();
-    }
-    function parseProjectionCallExpressionOrHigher() {
-        let expr = parseProjectionDecoratorReferenceExpressionOrHigher();
-        while (token() !== Token.EndOfFile) {
-            const pos = expr.pos;
-            expr = parseProjectionMemberExpressionRest(expr, pos);
-            if (token() === Token.OpenParen) {
-                expr = {
-                    kind: SyntaxKind.ProjectionCallExpression,
-                    callKind: "method",
-                    target: expr,
-                    arguments: parseList(ListKind.CallArguments, parseProjectionExpression).items,
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionDecoratorReferenceExpressionOrHigher() {
-        if (token() === Token.At) {
-            const pos = tokenPos();
-            nextToken();
-            return {
-                kind: SyntaxKind.ProjectionDecoratorReferenceExpression,
-                target: parseIdentifierOrMemberExpression(undefined, true),
-                ...finishNode(pos),
-            };
-        }
-        return parseProjectionMemberExpressionOrHigher();
-    }
-    function parseProjectionMemberExpressionOrHigher() {
-        const pos = tokenPos();
-        let expr = parseProjectionPrimaryExpression();
-        expr = parseProjectionMemberExpressionRest(expr, pos);
-        return expr;
-    }
-    function parseProjectionMemberExpressionRest(expr, pos) {
-        while (token() !== Token.EndOfFile) {
-            if (parseOptional(Token.Dot)) {
-                expr = {
-                    kind: SyntaxKind.ProjectionMemberExpression,
-                    base: expr,
-                    id: parseIdentifier(),
-                    selector: ".",
-                    ...finishNode(pos),
-                };
-            }
-            else if (parseOptional(Token.ColonColon)) {
-                expr = {
-                    kind: SyntaxKind.ProjectionMemberExpression,
-                    base: expr,
-                    id: parseIdentifier(),
-                    selector: "::",
-                    ...finishNode(pos),
-                };
-            }
-            else {
-                break;
-            }
-        }
-        return expr;
-    }
-    function parseProjectionPrimaryExpression() {
-        switch (token()) {
-            case Token.IfKeyword:
-                return parseProjectionIfExpression();
-            case Token.NumericLiteral:
-                return parseNumericLiteral();
-            case Token.StringLiteral:
-                return parseStringLiteral();
-            case Token.TrueKeyword:
-            case Token.FalseKeyword:
-                return parseBooleanLiteral();
-            case Token.OpenBracket:
-                return parseProjectionTupleExpression();
-            case Token.OpenBrace:
-                return parseProjectionModelExpression();
-            case Token.OpenParen:
-                return parseProjectionLambdaOrParenthesizedExpression();
-            case Token.VoidKeyword:
-                return parseVoidKeyword();
-            case Token.NeverKeyword:
-                return parseNeverKeyword();
-            case Token.UnknownKeyword:
-                return parseUnknownKeyword();
-            default:
-                return parseIdentifier({ message: "expression" });
-        }
-    }
-    function parseProjectionLambdaOrParenthesizedExpression() {
-        const pos = tokenPos();
-        const exprs = parseList(ListKind.ProjectionExpression, parseProjectionExpression).items;
-        if (token() === Token.EqualsGreaterThan) {
-            // unpack the exprs (which should be just identifiers) into a param list
-            const params = [];
-            for (const expr of exprs) {
-                if (expr.kind === SyntaxKind.Identifier) {
-                    params.push(withSymbol({
-                        kind: SyntaxKind.ProjectionLambdaParameterDeclaration,
-                        id: expr,
-                        pos: expr.pos,
-                        end: expr.end,
-                        flags: 0 /* NodeFlags.None */,
-                    }));
-                }
-                else {
-                    error({ code: "token-expected", messageId: "identifier", target: expr });
-                }
-            }
-            return parseProjectionLambdaExpressionRest(pos, params);
-        }
-        else {
-            if (exprs.length === 0) {
-                error({
-                    code: "token-expected",
-                    messageId: "expression",
-                });
-            }
-            // verify we only have one entry
-            for (let i = 1; i < exprs.length; i++) {
-                error({
-                    code: "token-expected",
-                    messageId: "unexpected",
-                    format: { token: "expression" },
-                    target: exprs[i],
-                });
-            }
-            return exprs[0];
-        }
+            kind: SyntaxKind.NumericLiteral,
+            value,
+            valueAsString,
+            ...finishNode(pos),
+        };
     }
-    function parseProjectionLambdaExpressionRest(pos, parameters) {
-        parseExpected(Token.EqualsGreaterThan);
-        const body = parseProjectionBlockExpression();
+    function parseBooleanLiteral() {
+        const pos = tokenPos();
+        const token = parseExpectedOneOf(Token.TrueKeyword, Token.FalseKeyword);
+        const value = token === Token.TrueKeyword;
         return {
-            kind: SyntaxKind.ProjectionLambdaExpression,
-            parameters,
-            body,
+            kind: SyntaxKind.BooleanLiteral,
+            value,
             ...finishNode(pos),
         };
     }
-    function parseProjectionModelExpression() {
+    function parseIdentifier(options) {
+        if (isKeyword(token())) {
+            error({ code: "reserved-identifier" });
+            return createMissingIdentifier();
+        }
+        else if (isReservedKeyword(token())) {
+            if (!options?.allowReservedIdentifier) {
+                error({ code: "reserved-identifier", messageId: "future", format: { name: tokenValue() } });
+            }
+        }
+        else if (token() !== Token.Identifier &&
+            (!options?.allowStringLiteral || token() !== Token.StringLiteral)) {
+            // Error recovery: when we fail to parse an identifier or expression,
+            // we insert a synthesized identifier with a unique name.
+            error({ code: "token-expected", messageId: options?.message ?? "identifier" });
+            return createMissingIdentifier();
+        }
         const pos = tokenPos();
-        const { items: properties } = parseList(ListKind.ModelProperties, parseProjectionModelPropertyOrSpread);
+        const sv = tokenValue();
+        nextToken();
         return {
-            kind: SyntaxKind.ProjectionModelExpression,
-            properties,
+            kind: SyntaxKind.Identifier,
+            sv,
             ...finishNode(pos),
         };
     }
-    function parseProjectionModelPropertyOrSpread(pos, decorators) {
-        return token() === Token.Ellipsis
-            ? parseProjectionModelSpreadProperty(pos, decorators)
-            : parseProjectionModelProperty(pos, decorators);
+    function parseDeclaration(pos) {
+        const modifiers = parseModifiers();
+        switch (token()) {
+            case Token.DecKeyword:
+                return parseDecoratorDeclarationStatement(pos, modifiers);
+            case Token.FnKeyword:
+                return parseFunctionDeclarationStatement(pos, modifiers);
+        }
+        return parseInvalidStatement(pos, []);
     }
-    function parseProjectionModelSpreadProperty(pos, decorators) {
-        parseExpected(Token.Ellipsis);
-        reportInvalidDecorators(decorators, "spread property");
-        const target = parseProjectionExpression();
+    function parseModifiers() {
+        const modifiers = [];
+        let modifier;
+        while ((modifier = parseModifier())) {
+            modifiers.push(modifier);
+        }
+        return modifiers;
+    }
+    function parseModifier() {
+        switch (token()) {
+            case Token.ExternKeyword:
+                return parseExternKeyword();
+            default:
+                return undefined;
+        }
+    }
+    function parseDecoratorDeclarationStatement(pos, modifiers) {
+        const modifierFlags = modifiersToFlags(modifiers);
+        parseExpected(Token.DecKeyword);
+        const id = parseIdentifier();
+        const allParamListDetail = parseFunctionParameters();
+        let [target, ...parameters] = allParamListDetail.items;
+        if (target === undefined) {
+            error({ code: "decorator-decl-target", target: { pos, end: previousTokenEnd } });
+            target = {
+                kind: SyntaxKind.FunctionParameter,
+                id: createMissingIdentifier(),
+                type: createMissingTypeReference(),
+                optional: false,
+                rest: false,
+                ...finishNode(pos),
+            };
+        }
+        if (target.optional) {
+            error({ code: "decorator-decl-target", messageId: "required" });
+        }
+        parseExpected(Token.Semicolon);
         return {
-            kind: SyntaxKind.ProjectionModelSpreadProperty,
+            kind: SyntaxKind.DecoratorDeclarationStatement,
+            modifiers,
+            modifierFlags,
+            id,
             target,
+            parameters,
             ...finishNode(pos),
         };
     }
-    function parseProjectionModelProperty(pos, decorators) {
-        const id = parseIdentifier({ message: "property", allowStringLiteral: true });
-        const optional = parseOptional(Token.Question);
-        parseExpected(Token.Colon);
-        const value = parseProjectionExpression();
-        const hasDefault = parseOptional(Token.Equals);
-        const defaultValue = hasDefault ? parseProjectionExpression() : undefined;
+    function parseFunctionDeclarationStatement(pos, modifiers) {
+        const modifierFlags = modifiersToFlags(modifiers);
+        parseExpected(Token.FnKeyword);
+        const id = parseIdentifier();
+        const { items: parameters } = parseFunctionParameters();
+        let returnType;
+        if (parseOptional(Token.Colon)) {
+            returnType = parseExpression();
+        }
+        parseExpected(Token.Semicolon);
         return {
-            kind: SyntaxKind.ProjectionModelProperty,
+            kind: SyntaxKind.FunctionDeclarationStatement,
+            modifiers,
+            modifierFlags,
             id,
-            decorators,
-            value,
-            optional,
-            default: defaultValue,
+            parameters,
+            returnType,
             ...finishNode(pos),
         };
     }
-    function parseProjectionIfExpression() {
-        const pos = tokenPos();
-        parseExpected(Token.IfKeyword);
-        const test = parseProjectionExpression();
-        const consequent = parseProjectionBlockExpression();
-        let alternate = undefined;
-        if (parseOptional(Token.ElseKeyword)) {
-            if (token() === Token.IfKeyword) {
-                alternate = parseProjectionIfExpression();
+    function parseFunctionParameters() {
+        const parameters = parseList(ListKind.FunctionParameters, parseFunctionParameter);
+        let foundOptional = false;
+        for (const [index, item] of parameters.items.entries()) {
+            if (!item.optional && foundOptional) {
+                error({ code: "required-parameter-first", target: item });
+                continue;
             }
-            else {
-                alternate = parseProjectionBlockExpression();
+            if (item.optional) {
+                foundOptional = true;
+            }
+            if (item.rest && item.optional) {
+                error({ code: "rest-parameter-required", target: item });
+            }
+            if (item.rest && index !== parameters.items.length - 1) {
+                error({ code: "rest-parameter-last", target: item });
             }
         }
-        return {
-            kind: SyntaxKind.ProjectionIfExpression,
-            test,
-            consequent,
-            alternate,
-            ...finishNode(pos),
-        };
-    }
-    function parseProjectionBlockExpression() {
-        const pos = tokenPos();
-        parseExpected(Token.OpenBrace);
-        const statements = parseProjectionStatementList();
-        parseExpected(Token.CloseBrace);
-        return {
-            kind: SyntaxKind.ProjectionBlockExpression,
-            statements,
-            ...finishNode(pos),
-        };
+        return parameters;
     }
-    function parseProjectionTupleExpression() {
+    function parseFunctionParameter() {
         const pos = tokenPos();
-        const { items: values } = parseList(ListKind.Tuple, parseProjectionExpression);
+        const rest = parseOptional(Token.Ellipsis);
+        const id = parseIdentifier({ message: "property" });
+        const optional = parseOptional(Token.Question);
+        let type;
+        if (parseOptional(Token.Colon)) {
+            type = parseMixedParameterConstraint();
+        }
         return {
-            kind: SyntaxKind.ProjectionTupleExpression,
-            values,
+            kind: SyntaxKind.FunctionParameter,
+            id,
+            type,
+            optional,
+            rest,
             ...finishNode(pos),
         };
     }
-    function parseProjectionSelector() {
-        const pos = tokenPos();
-        const selectorTok = expectTokenIsOneOf(Token.Identifier, Token.ModelKeyword, Token.OpKeyword, Token.InterfaceKeyword, Token.UnionKeyword, Token.EnumKeyword, Token.ScalarKeyword);
-        switch (selectorTok) {
-            case Token.Identifier:
-                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 {
-                    kind: SyntaxKind.ProjectionModelSelector,
-                    ...finishNode(pos),
-                };
-            case Token.OpKeyword:
-                nextToken();
-                return {
-                    kind: SyntaxKind.ProjectionOperationSelector,
-                    ...finishNode(pos),
-                };
-            case Token.InterfaceKeyword:
-                nextToken();
-                return {
-                    kind: SyntaxKind.ProjectionInterfaceSelector,
-                    ...finishNode(pos),
-                };
-            case Token.UnionKeyword:
-                nextToken();
-                return {
-                    kind: SyntaxKind.ProjectionUnionSelector,
-                    ...finishNode(pos),
-                };
-            case Token.EnumKeyword:
-                nextToken();
-                return {
-                    kind: SyntaxKind.ProjectionEnumSelector,
-                    ...finishNode(pos),
-                };
-            case Token.ScalarKeyword:
-                nextToken();
-                return {
-                    kind: SyntaxKind.ProjectionScalarSelector,
-                    ...finishNode(pos),
-                };
-            default:
-                // recovery: return a missing identifier to use as the selector
-                // we don't need to emit a diagnostic here as the `expectTokenOneOf` above
-                // will have done so.
-                return createMissingIdentifier();
+    function modifiersToFlags(modifiers) {
+        let flags = 0 /* ModifierFlags.None */;
+        for (const modifier of modifiers) {
+            switch (modifier.kind) {
+                case SyntaxKind.ExternKeyword:
+                    flags |= 2 /* ModifierFlags.Extern */;
+                    break;
+            }
         }
+        return flags;
     }
     function parseRange(mode, range, callback) {
         const savedMode = currentMode;
@@ -6428,58 +6000,12 @@ function visitChildren(node, cb) {
             return visitEach(cb, node.values);
         case SyntaxKind.UnionExpression:
             return visitEach(cb, node.options);
-        case SyntaxKind.Projection:
-            return (visitNode(cb, node.directionId) ||
-                visitEach(cb, node.modifierIds) ||
-                visitEach(cb, node.parameters) ||
-                visitEach(cb, node.body));
-        case SyntaxKind.ProjectionExpressionStatement:
-            return visitNode(cb, node.expr);
-        case SyntaxKind.ProjectionCallExpression:
-            return visitNode(cb, node.target) || visitEach(cb, node.arguments);
-        case SyntaxKind.ProjectionMemberExpression:
-            return visitNode(cb, node.base) || visitNode(cb, node.id);
-        // binops
-        case SyntaxKind.ProjectionLogicalExpression:
-        case SyntaxKind.ProjectionRelationalExpression:
-        case SyntaxKind.ProjectionArithmeticExpression:
-        case SyntaxKind.ProjectionEqualityExpression:
-            return visitNode(cb, node.left) || visitNode(cb, node.right);
-        case SyntaxKind.ProjectionUnaryExpression:
-            return visitNode(cb, node.target);
-        case SyntaxKind.ProjectionModelExpression:
-            return visitEach(cb, node.properties);
-        case SyntaxKind.ProjectionModelProperty:
-            return (visitEach(cb, node.decorators) ||
-                visitNode(cb, node.id) ||
-                visitNode(cb, node.value) ||
-                visitNode(cb, node.default));
-        case SyntaxKind.ProjectionModelSpreadProperty:
-            return visitNode(cb, node.target);
-        case SyntaxKind.ProjectionTupleExpression:
-            return visitEach(cb, node.values);
-        case SyntaxKind.ProjectionBlockExpression:
-            return visitEach(cb, node.statements);
-        case SyntaxKind.ProjectionIfExpression:
-            return (visitNode(cb, node.test) || visitNode(cb, node.consequent) || visitNode(cb, node.alternate));
-        case SyntaxKind.ProjectionLambdaExpression:
-            return visitEach(cb, node.parameters) || visitNode(cb, node.body);
-        case SyntaxKind.ProjectionStatement:
-            return (visitNode(cb, node.id) || visitNode(cb, node.selector) || visitEach(cb, node.projections));
-        case SyntaxKind.ProjectionDecoratorReferenceExpression:
-            return visitNode(cb, node.target);
-        case SyntaxKind.Return:
-            return visitNode(cb, node.value);
         case SyntaxKind.InvalidStatement:
             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:
-            return visitNode(cb, node.id);
         case SyntaxKind.Doc:
             return visitEach(cb, node.content) || visitEach(cb, node.tags);
         case SyntaxKind.DocParamTag:
@@ -6512,15 +6038,6 @@ function visitChildren(node, cb) {
         case SyntaxKind.BooleanLiteral:
         case SyntaxKind.Identifier:
         case SyntaxKind.EmptyStatement:
-        case SyntaxKind.ProjectionModelSelector:
-        case SyntaxKind.ProjectionModelPropertySelector:
-        case SyntaxKind.ProjectionScalarSelector:
-        case SyntaxKind.ProjectionUnionSelector:
-        case SyntaxKind.ProjectionUnionVariantSelector:
-        case SyntaxKind.ProjectionInterfaceSelector:
-        case SyntaxKind.ProjectionOperationSelector:
-        case SyntaxKind.ProjectionEnumSelector:
-        case SyntaxKind.ProjectionEnumMemberSelector:
         case SyntaxKind.VoidKeyword:
         case SyntaxKind.NeverKeyword:
         case SyntaxKind.ExternKeyword:
@@ -7868,6 +7385,7 @@ function addCommentBetweenAnnotationsAndNode({ comment }) {
             enclosingNode.kind === SyntaxKind.InterfaceStatement ||
             enclosingNode.kind === SyntaxKind.ModelProperty ||
             enclosingNode.kind === SyntaxKind.EnumMember ||
+            enclosingNode.kind === SyntaxKind.UnionVariant ||
             enclosingNode.kind === SyntaxKind.UnionStatement)) {
         util.addTrailingComment(precedingNode, comment);
         return true;
@@ -7964,10 +7482,6 @@ function needsParens(path, options) {
         case SyntaxKind.UnionExpression:
             return (parent.kind === SyntaxKind.IntersectionExpression ||
                 parent.kind === SyntaxKind.ArrayExpression);
-        case SyntaxKind.ProjectionLogicalExpression:
-            return parent.kind === SyntaxKind.ProjectionLogicalExpression;
-        case SyntaxKind.ProjectionArithmeticExpression:
-            return parent.kind === SyntaxKind.ProjectionArithmeticExpression;
         default:
             return false;
     }
@@ -8107,63 +7621,6 @@ path, options, print) {
             return "never";
         case SyntaxKind.UnknownKeyword:
             return "unknown";
-        case SyntaxKind.ProjectionStatement:
-            return printProjectionStatement(path, options, print);
-        case SyntaxKind.ProjectionModelSelector:
-            return "model";
-        case SyntaxKind.ProjectionModelPropertySelector:
-            return "modelproperty";
-        case SyntaxKind.ProjectionScalarSelector:
-            return "scalar";
-        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:
-            return printProjectionParameterDeclaration(path, options, print);
-        case SyntaxKind.ProjectionExpressionStatement:
-            return printProjectionExpressionStatement(path, options, print);
-        case SyntaxKind.ProjectionIfExpression:
-            return printProjectionIfExpressionNode(path, options, print);
-        case SyntaxKind.ProjectionBlockExpression:
-            return printProjectionBlockExpressionNode(path, options, print);
-        case SyntaxKind.ProjectionMemberExpression:
-            return printProjectionMemberExpression(path, options, print);
-        case SyntaxKind.ProjectionLogicalExpression:
-        case SyntaxKind.ProjectionEqualityExpression:
-        case SyntaxKind.ProjectionRelationalExpression:
-        case SyntaxKind.ProjectionArithmeticExpression:
-            return printProjectionLeftRightExpression(path, options, print);
-        case SyntaxKind.ProjectionUnaryExpression:
-            return printProjectionUnaryExpression(path, options, print);
-        case SyntaxKind.ProjectionCallExpression:
-            return printProjectionCallExpression(path, options, print);
-        case SyntaxKind.ProjectionLambdaExpression:
-            return printProjectionLambdaExpression(path, options, print);
-        case SyntaxKind.ProjectionLambdaParameterDeclaration:
-            return printProjectionLambdaParameterDeclaration(path, options, print);
-        case SyntaxKind.ProjectionModelExpression:
-            return printModelExpression(path, options, print);
-        case SyntaxKind.ProjectionModelProperty:
-            return printModelProperty(path, options, print);
-        case SyntaxKind.ProjectionModelSpreadProperty:
-            return printModelSpread(path, options, print);
-        case SyntaxKind.ProjectionTupleExpression:
-            return printTuple(path, options, print);
-        case SyntaxKind.ProjectionDecoratorReferenceExpression:
-            return path.call(print, "target");
-        case SyntaxKind.Return:
-            return printReturnExpression(path, options, print);
         case SyntaxKind.Doc:
             return printDoc(path, options);
         case SyntaxKind.DocText:
@@ -8329,7 +7786,11 @@ function hasNewlineBetweenOrAfterDecorators(node, options) {
 }
 function printDecorator(path, options, print) {
     const args = printDecoratorArgs(path, options, print);
-    return ["@", path.call(print, "target"), args];
+    const node = path.node;
+    const name = node.target.kind === SyntaxKind.Identifier
+        ? printIdentifier(node.target, "allow-reserved")
+        : path.call(print, "target");
+    return ["@", name, args];
 }
 function printAugmentDecorator(path, options, print) {
     const args = printAugmentDecoratorArgs(path, options, print);
@@ -8425,7 +7886,7 @@ function printEnumBlock(path, options, print) {
 }
 function printEnumMember(path, options, print) {
     const node = path.node;
-    const id = path.call(print, "id");
+    const id = printIdentifier(node.id, "allow-reserved");
     const value = node.value ? [": ", path.call(print, "value")] : "";
     const { decorators } = printDecorators(path, options, print, {
         tryInline: DecoratorsTryInline.enumMember,
@@ -8450,7 +7911,7 @@ function printUnionVariantsBlock(path, options, print) {
     return group(["{", indent(body), hardline, "}"]);
 }
 function printUnionVariant(path, options, print) {
-    const id = path.node.id === undefined ? "" : [path.call(print, "id"), ": "];
+    const id = path.node.id === undefined ? "" : [printIdentifier(path.node.id, "allow-reserved"), ": "];
     const { decorators } = printDecorators(path, options, print, {
         tryInline: DecoratorsTryInline.unionVariant,
     });
@@ -8576,7 +8037,8 @@ function printTuple(path, options, print) {
 }
 function printMemberExpression(path, options, print) {
     const node = path.node;
-    return [node.base ? [path.call(print, "base"), node.selector] : "", path.call(print, "id")];
+    const id = printIdentifier(node.id, "allow-reserved");
+    return [node.base ? [path.call(print, "base"), node.selector] : "", id];
 }
 function printModelExpression(path, options, print) {
     const inBlock = isModelExpressionInBlock(path);
@@ -8609,7 +8071,7 @@ function printObjectLiteral(path, options, print) {
 }
 function printObjectLiteralProperty(path, options, print) {
     const node = path.node;
-    const id = printIdentifier(node.id);
+    const id = printIdentifier(node.id, "allow-reserved");
     return [printDirectives(path, options, print), id, ": ", path.call(print, "value")];
 }
 function printObjectLiteralSpreadProperty(path, options, print) {
@@ -8703,7 +8165,6 @@ function joinMembersInBlock(path, member, options, print, separator, regularLine
 function shouldWrapMemberInNewLines(path, options) {
     const node = path.node;
     return ((node.kind !== SyntaxKind.ModelSpreadProperty &&
-        node.kind !== SyntaxKind.ProjectionModelSpreadProperty &&
         node.kind !== SyntaxKind.EnumSpreadMember &&
         node.kind !== SyntaxKind.ScalarConstructor &&
         node.kind !== SyntaxKind.ObjectLiteralProperty &&
@@ -8738,7 +8199,7 @@ function printModelProperty(path, options, print) {
     const { decorators } = printDecorators(path, options, print, {
         tryInline: DecoratorsTryInline.modelProperty,
     });
-    const id = printIdentifier(node.id);
+    const id = printIdentifier(node.id, "allow-reserved");
     return [
         printDirectives(path, options, print),
         decorators,
@@ -8748,8 +8209,8 @@ function printModelProperty(path, options, print) {
         node.default ? [" = ", path.call(print, "default")] : "",
     ];
 }
-function printIdentifier(id, options) {
-    return printIdentifier$1(id.sv);
+function printIdentifier(id, context = "disallow-reserved") {
+    return printIdentifier$1(id.sv, context);
 }
 function isModelExpressionInBlock(path) {
     const parent = path.getParentNode();
@@ -8993,132 +8454,6 @@ function printBooleanLiteral(path, options) {
     const node = path.node;
     return node.value ? "true" : "false";
 }
-function printProjectionStatement(path, options, print) {
-    const selector = path.call(print, "selector");
-    const id = path.call(print, "id");
-    const projections = path.map(print, "projections").flatMap((x) => [hardline, x]);
-    return [
-        "projection ",
-        selector,
-        "#",
-        id,
-        " {",
-        indent(projections),
-        projections.length > 0 ? hardline : "",
-        "}",
-    ];
-}
-function printProjection(path, options, print) {
-    const node = path.node;
-    const params = printProjectionParameters(path, options, print);
-    const body = printProjectionExpressionStatements(path, options, print, "body");
-    return [
-        ...node.modifierIds.flatMap((i) => [i.sv, " "]),
-        node.directionId.sv,
-        params,
-        " {",
-        indent(body),
-        hardline,
-        "}",
-    ];
-}
-function printProjectionParameters(path, options, print) {
-    const node = path.node;
-    const params = node.parameters;
-    if (params.length === 0) {
-        return "";
-    }
-    const shouldHug = params.length === 1;
-    if (shouldHug) {
-        return ["(", printItemList(path, options, print, "parameters"), ")"];
-    }
-    else {
-        const body = indent([softline, join([", ", softline], path.map(print, "parameters"))]);
-        return group(["(", body, softline, ")"]);
-    }
-}
-function printProjectionExpressionStatements(path, options, print, key) {
-    const parts = [hardline];
-    const lastIndex = path.node[key].length - 1;
-    path.each((statementPath, index) => {
-        const node = path.node;
-        if (node.kind === SyntaxKind.EmptyStatement) {
-            return;
-        }
-        const printed = print(statementPath);
-        parts.push(printed);
-        parts.push(";");
-        if (index < lastIndex) {
-            parts.push(hardline);
-            if (isNextLineEmpty(options.originalText, node, options.locEnd)) {
-                parts.push(hardline);
-            }
-        }
-    }, key);
-    return parts;
-}
-function printProjectionParameterDeclaration(path, options, print) {
-    return path.call(print, "id");
-}
-function printProjectionExpressionStatement(path, options, print) {
-    return path.call(print, "expr");
-}
-function printProjectionIfExpressionNode(path, options, print) {
-    const node = path.node;
-    const test = path.call(print, "test");
-    const consequent = path.call(print, "consequent");
-    const alternate = node.alternate ? [" else ", path.call(print, "alternate")] : "";
-    return ["if ", test, " ", consequent, alternate];
-}
-function printProjectionBlockExpressionNode(path, options, print) {
-    const node = path.node;
-    if (node.statements.length === 0) {
-        return "{}";
-    }
-    return [
-        "{",
-        indent(printProjectionExpressionStatements(path, options, print, "statements")),
-        hardline,
-        "}",
-    ];
-}
-function printProjectionMemberExpression(path, options, print) {
-    const node = path.node;
-    return [path.call(print, "base"), node.selector, path.call(print, "id")];
-}
-function printProjectionLeftRightExpression(path, options, print) {
-    const node = path.node;
-    return [path.call(print, "left"), " ", node.op, " ", path.call(print, "right")];
-}
-function printProjectionUnaryExpression(path, options, print) {
-    return ["!", path.call(print, "target")];
-}
-function printProjectionCallExpression(path, options, print) {
-    const node = path.node;
-    const target = path.call(print, "target");
-    const params = printItemList(path, options, print, "arguments");
-    if (node.callKind === "method") {
-        return [target, "(", params, ")"];
-    }
-    else {
-        return [target, "<", params, ">"];
-    }
-}
-function printProjectionLambdaExpression(path, options, print) {
-    return [
-        "(",
-        printItemList(path, options, print, "parameters"),
-        ")",
-        " => ",
-        path.call(print, "body"),
-    ];
-}
-function printProjectionLambdaParameterDeclaration(path, options, print) {
-    return path.call(print, "id");
-}
-function printReturnExpression(path, options, print) {
-    return ["return ", path.call(print, "value")];
-}
 function printStringTemplateExpression(path, options, print) {
     const node = path.node;
     const multiline = isMultiline(node, options);
@@ -9164,9 +8499,6 @@ function trimMultilineString(lines, whitespaceIndent) {
     }
     return newLines;
 }
-function printItemList(path, options, print, key) {
-    return join(", ", path.map(print, key));
-}
 /**
  * @param node Node that has postition information.
  * @param options Prettier options
@@ -9246,7 +8578,7 @@ const printers = {
     "typespec-format": typespecPrinter,
 };
 
-var formatter = /*#__PURE__*/Object.freeze({
+var TypeSpecPrettierPlugin = /*#__PURE__*/Object.freeze({
     __proto__: null,
     defaultOptions: defaultOptions,
     languages: languages,
@@ -9254,8 +8586,6 @@ var formatter = /*#__PURE__*/Object.freeze({
     printers: printers
 });
 
-const TypeSpecPrettierPlugin = formatter;
-
 /**
  * Reexport the bare minimum for rollup to do the tree shaking.
  */