@typespec/compiler 0.67.0-dev.8 → 0.67.0

package/dist/src/core/parser.js

@@ -2,7 +2,7 @@ import { isArray, mutate } from "../utils/misc.js";
 import { codePointBefore, isIdentifierContinue, trim } from "./charcode.js";
 import { compilerAssert } from "./diagnostics.js";
 import { createDiagnostic } from "./messages.js";
-import { createScanner, isComment, isKeyword, isPunctuation, isStatementKeyword, isTrivia, skipContinuousIdentifier, skipTrivia, skipTriviaBackward, Token, TokenDisplay, TokenFlags, } from "./scanner.js";
+import { createScanner, isComment, isKeyword, isPunctuation, isReservedKeyword, isStatementKeyword, isTrivia, skipContinuousIdentifier, skipTrivia, skipTriviaBackward, Token, TokenDisplay, TokenFlags, } from "./scanner.js";
 import { IdentifierKind, SyntaxKind, } from "./types.js";
 /**
  * The fixed set of options for each of the kinds of delimited lists in TypeSpec.
@@ -122,18 +122,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 = {}));
 export function parse(code, options = {}) {
     const parser = createParser(code, options);
@@ -266,10 +254,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);
@@ -370,10 +354,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;
@@ -500,8 +480,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 &&
@@ -544,7 +544,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,
@@ -724,6 +724,7 @@ function createParser(code, options = {}) {
         const id = parseIdentifier({
             message: "property",
             allowStringLiteral: true,
+            allowReservedIdentifier: true,
         });
         const optional = parseOptional(Token.Question);
         parseExpected(Token.Colon);
@@ -759,6 +760,7 @@ function createParser(code, options = {}) {
     function parseObjectLiteralProperty(pos) {
         const id = parseIdentifier({
             message: "property",
+            allowReservedIdentifier: true,
         });
         parseExpected(Token.Colon);
         const value = parseExpression();
@@ -845,6 +847,7 @@ function createParser(code, options = {}) {
         const id = parseIdentifier({
             message: "enumMember",
             allowStringLiteral: true,
+            allowReservedIdentifier: true,
         });
         let value;
         if (parseOptional(Token.Colon)) {
@@ -1012,12 +1015,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 {
@@ -1080,7 +1089,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" });
@@ -1136,7 +1145,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,
@@ -1197,11 +1209,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)) {
@@ -1214,7 +1226,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),
@@ -1474,8 +1486,14 @@ function createParser(code, options = {}) {
         };
     }
     function parseIdentifier(options) {
-        if (options?.recoverFromKeyword !== false && isKeyword(token())) {
+        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)) {
@@ -1619,570 +1637,6 @@ function createParser(code, options = {}) {
         }
         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];
-        }
-    }
-    function parseProjectionLambdaExpressionRest(pos, parameters) {
-        parseExpected(Token.EqualsGreaterThan);
-        const body = parseProjectionBlockExpression();
-        return {
-            kind: SyntaxKind.ProjectionLambdaExpression,
-            parameters,
-            body,
-            ...finishNode(pos),
-        };
-    }
-    function parseProjectionModelExpression() {
-        const pos = tokenPos();
-        const { items: properties } = parseList(ListKind.ModelProperties, parseProjectionModelPropertyOrSpread);
-        return {
-            kind: SyntaxKind.ProjectionModelExpression,
-            properties,
-            ...finishNode(pos),
-        };
-    }
-    function parseProjectionModelPropertyOrSpread(pos, decorators) {
-        return token() === Token.Ellipsis
-            ? parseProjectionModelSpreadProperty(pos, decorators)
-            : parseProjectionModelProperty(pos, decorators);
-    }
-    function parseProjectionModelSpreadProperty(pos, decorators) {
-        parseExpected(Token.Ellipsis);
-        reportInvalidDecorators(decorators, "spread property");
-        const target = parseProjectionExpression();
-        return {
-            kind: SyntaxKind.ProjectionModelSpreadProperty,
-            target,
-            ...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;
-        return {
-            kind: SyntaxKind.ProjectionModelProperty,
-            id,
-            decorators,
-            value,
-            optional,
-            default: defaultValue,
-            ...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();
-            }
-            else {
-                alternate = parseProjectionBlockExpression();
-            }
-        }
-        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),
-        };
-    }
-    function parseProjectionTupleExpression() {
-        const pos = tokenPos();
-        const { items: values } = parseList(ListKind.Tuple, parseProjectionExpression);
-        return {
-            kind: SyntaxKind.ProjectionTupleExpression,
-            values,
-            ...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 parseRange(mode, range, callback) {
         const savedMode = currentMode;
         const result = scanner.scanRange(range, () => {
@@ -2925,58 +2379,12 @@ export 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:
@@ -3009,15 +2417,6 @@ export 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:
@@ -3193,9 +2592,6 @@ export function getIdentifierContext(id) {
         case SyntaxKind.DecoratorExpression:
             kind = IdentifierKind.Decorator;
             break;
-        case SyntaxKind.ProjectionCallExpression:
-            kind = IdentifierKind.Function;
-            break;
         case SyntaxKind.UsingStatement:
             kind = IdentifierKind.Using;
             break;