@typespec/compiler 0.57.0-dev.0 → 0.57.0-dev.13

package/dist/src/core/parser.js

@@ -27,6 +27,10 @@ var ListKind;
         ...ListKind.OperationParameters,
         invalidAnnotationTarget: "expression",
     };
+    ListKind.FunctionArguments = {
+        ...ListKind.OperationParameters,
+        invalidAnnotationTarget: "expression",
+    };
     ListKind.ModelProperties = {
         ...PropertiesBase,
         open: Token.OpenBrace,
@@ -34,6 +38,13 @@ var ListKind;
         delimiter: Token.Semicolon,
         toleratedDelimiter: Token.Comma,
     };
+    ListKind.ObjectLiteralProperties = {
+        ...PropertiesBase,
+        open: Token.HashBrace,
+        close: Token.CloseBrace,
+        delimiter: Token.Comma,
+        toleratedDelimiter: Token.Comma,
+    };
     ListKind.InterfaceMembers = {
         ...PropertiesBase,
         open: Token.OpenBrace,
@@ -43,6 +54,15 @@ var ListKind;
         toleratedDelimiterIsValid: false,
         allowedStatementKeyword: Token.OpKeyword,
     };
+    ListKind.ScalarMembers = {
+        ...PropertiesBase,
+        open: Token.OpenBrace,
+        close: Token.CloseBrace,
+        delimiter: Token.Semicolon,
+        toleratedDelimiter: Token.Comma,
+        toleratedDelimiterIsValid: false,
+        allowedStatementKeyword: Token.InitKeyword,
+    };
     ListKind.UnionVariants = {
         ...PropertiesBase,
         open: Token.OpenBrace,
@@ -91,6 +111,12 @@ var ListKind;
         open: Token.OpenBracket,
         close: Token.CloseBracket,
     };
+    ListKind.ArrayLiteral = {
+        ...ExpresionsBase,
+        allowEmpty: true,
+        open: Token.HashBracket,
+        close: Token.CloseBracket,
+    };
     ListKind.FunctionParameters = {
         ...ExpresionsBase,
         allowEmpty: true,
@@ -234,6 +260,10 @@ function createParser(code, options = {}) {
                     reportInvalidDecorators(decorators, "alias statement");
                     item = parseAliasStatement(pos);
                     break;
+                case Token.ConstKeyword:
+                    reportInvalidDecorators(decorators, "const statement");
+                    item = parseConstStatement(pos);
+                    break;
                 case Token.UsingKeyword:
                     reportInvalidDecorators(decorators, "using statement");
                     item = parseUsingStatement(pos);
@@ -329,6 +359,10 @@ function createParser(code, options = {}) {
                     reportInvalidDecorators(decorators, "alias statement");
                     item = parseAliasStatement(pos);
                     break;
+                case Token.ConstKeyword:
+                    reportInvalidDecorators(decorators, "const statement");
+                    item = parseConstStatement(pos);
+                    break;
                 case Token.UsingKeyword:
                     reportInvalidDecorators(decorators, "using statement");
                     item = parseUsingStatement(pos);
@@ -622,7 +656,7 @@ function createParser(code, options = {}) {
         const id = parseIdentifier();
         let constraint;
         if (parseOptional(Token.ExtendsKeyword)) {
-            constraint = parseExpression();
+            constraint = parseMixedParameterConstraint();
         }
         let def;
         if (parseOptional(Token.Equals)) {
@@ -636,6 +670,35 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseValueOfExpressionOrIntersectionOrHigher() {
+        if (token() === Token.ValueOfKeyword) {
+            return parseValueOfExpression();
+        }
+        else if (parseOptional(Token.OpenParen)) {
+            const expr = parseMixedParameterConstraint();
+            parseExpected(Token.CloseParen);
+            return expr;
+        }
+        return parseIntersectionExpressionOrHigher();
+    }
+    function parseMixedParameterConstraint() {
+        const pos = tokenPos();
+        parseOptional(Token.Bar);
+        const node = parseValueOfExpressionOrIntersectionOrHigher();
+        if (token() !== Token.Bar) {
+            return node;
+        }
+        const options = [node];
+        while (parseOptional(Token.Bar)) {
+            const expr = parseValueOfExpressionOrIntersectionOrHigher();
+            options.push(expr);
+        }
+        return {
+            kind: SyntaxKind.UnionExpression,
+            options,
+            ...finishNode(pos),
+        };
+    }
     function parseModelPropertyOrSpread(pos, decorators) {
         return token() === Token.Ellipsis
             ? parseModelSpreadProperty(pos, decorators)
@@ -672,16 +735,47 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseObjectLiteralPropertyOrSpread(pos, decorators) {
+        reportInvalidDecorators(decorators, "object literal property");
+        return token() === Token.Ellipsis
+            ? parseObjectLiteralSpreadProperty(pos)
+            : parseObjectLiteralProperty(pos);
+    }
+    function parseObjectLiteralSpreadProperty(pos) {
+        parseExpected(Token.Ellipsis);
+        // This could be broadened to allow any type expression
+        const target = parseReferenceExpression();
+        return {
+            kind: SyntaxKind.ObjectLiteralSpreadProperty,
+            target,
+            ...finishNode(pos),
+        };
+    }
+    function parseObjectLiteralProperty(pos) {
+        const id = parseIdentifier({
+            message: "property",
+        });
+        parseExpected(Token.Colon);
+        const value = parseExpression();
+        return {
+            kind: SyntaxKind.ObjectLiteralProperty,
+            id,
+            value,
+            ...finishNode(pos),
+        };
+    }
     function parseScalarStatement(pos, decorators) {
         parseExpected(Token.ScalarKeyword);
         const id = parseIdentifier();
         const templateParameters = parseTemplateParameterList();
         const optionalExtends = parseOptionalScalarExtends();
+        const members = parseScalarMembers();
         return {
             kind: SyntaxKind.ScalarStatement,
             id,
             templateParameters,
             extends: optionalExtends,
+            members,
             decorators,
             ...finishNode(pos),
         };
@@ -692,6 +786,27 @@ function createParser(code, options = {}) {
         }
         return undefined;
     }
+    function parseScalarMembers() {
+        if (token() === Token.Semicolon) {
+            nextToken();
+            return [];
+        }
+        else {
+            return parseList(ListKind.ScalarMembers, parseScalarMember);
+        }
+    }
+    function parseScalarMember(pos, decorators) {
+        reportInvalidDecorators(decorators, "scalar member");
+        parseExpected(Token.InitKeyword);
+        const id = parseIdentifier();
+        const parameters = parseFunctionParameters();
+        return {
+            kind: SyntaxKind.ScalarConstructor,
+            id,
+            parameters,
+            ...finishNode(pos),
+        };
+    }
     function parseEnumStatement(pos, decorators) {
         parseExpected(Token.EnumKeyword);
         const id = parseIdentifier();
@@ -761,6 +876,27 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseConstStatement(pos) {
+        parseExpected(Token.ConstKeyword);
+        const id = parseIdentifier();
+        const type = parseOptionalTypeAnnotation();
+        parseExpected(Token.Equals);
+        const value = parseExpression();
+        parseExpected(Token.Semicolon);
+        return {
+            kind: SyntaxKind.ConstStatement,
+            id,
+            value,
+            type,
+            ...finishNode(pos),
+        };
+    }
+    function parseOptionalTypeAnnotation() {
+        if (parseOptional(Token.Colon)) {
+            return parseExpression();
+        }
+        return undefined;
+    }
     function parseExpression() {
         return parseUnionExpressionOrHigher();
     }
@@ -830,9 +966,61 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseTypeOfExpression() {
+        const pos = tokenPos();
+        parseExpected(Token.TypeOfKeyword);
+        const target = parseTypeOfTarget();
+        return {
+            kind: SyntaxKind.TypeOfExpression,
+            target,
+            ...finishNode(pos),
+        };
+    }
+    function parseTypeOfTarget() {
+        while (true) {
+            switch (token()) {
+                case Token.TypeOfKeyword:
+                    return parseTypeOfExpression();
+                case Token.Identifier:
+                    return parseCallOrReferenceExpression();
+                case Token.StringLiteral:
+                    return parseStringLiteral();
+                case Token.StringTemplateHead:
+                    return parseStringTemplateExpression();
+                case Token.TrueKeyword:
+                case Token.FalseKeyword:
+                    return parseBooleanLiteral();
+                case Token.NumericLiteral:
+                    return parseNumericLiteral();
+                case Token.OpenParen:
+                    parseExpected(Token.OpenParen);
+                    const target = parseTypeOfTarget();
+                    parseExpected(Token.CloseParen);
+                    return target;
+                default:
+                    return parseReferenceExpression("typeofTarget");
+            }
+        }
+    }
     function parseReferenceExpression(message) {
         const pos = tokenPos();
         const target = parseIdentifierOrMemberExpression(message);
+        return parseReferenceExpressionInternal(target, pos);
+    }
+    function parseCallOrReferenceExpression(message) {
+        const pos = tokenPos();
+        const target = parseIdentifierOrMemberExpression(message);
+        if (token() === Token.OpenParen) {
+            return {
+                kind: SyntaxKind.CallExpression,
+                target,
+                arguments: parseList(ListKind.FunctionArguments, parseExpression),
+                ...finishNode(pos),
+            };
+        }
+        return parseReferenceExpressionInternal(target, pos);
+    }
+    function parseReferenceExpressionInternal(target, pos) {
         const args = parseOptionalList(ListKind.TemplateArguments, parseTemplateArgument);
         return {
             kind: SyntaxKind.TypeReference,
@@ -1039,10 +1227,10 @@ function createParser(code, options = {}) {
     function parsePrimaryExpression() {
         while (true) {
             switch (token()) {
-                case Token.ValueOfKeyword:
-                    return parseValueOfExpression();
+                case Token.TypeOfKeyword:
+                    return parseTypeOfExpression();
                 case Token.Identifier:
-                    return parseReferenceExpression();
+                    return parseCallOrReferenceExpression();
                 case Token.StringLiteral:
                     return parseStringLiteral();
                 case Token.StringTemplateHead:
@@ -1066,6 +1254,10 @@ function createParser(code, options = {}) {
                     const directives = parseDirectiveList();
                     reportInvalidDirective(directives, "expression");
                     continue;
+                case Token.HashBrace:
+                    return parseObjectLiteral();
+                case Token.HashBracket:
+                    return parseArrayLiteral();
                 case Token.VoidKeyword:
                     return parseVoidKeyword();
                 case Token.NeverKeyword:
@@ -1134,6 +1326,24 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseObjectLiteral() {
+        const pos = tokenPos();
+        const properties = parseList(ListKind.ObjectLiteralProperties, parseObjectLiteralPropertyOrSpread);
+        return {
+            kind: SyntaxKind.ObjectLiteral,
+            properties,
+            ...finishNode(pos),
+        };
+    }
+    function parseArrayLiteral() {
+        const pos = tokenPos();
+        const values = parseList(ListKind.ArrayLiteral, parseExpression);
+        return {
+            kind: SyntaxKind.ArrayLiteral,
+            values,
+            ...finishNode(pos),
+        };
+    }
     function parseStringLiteral() {
         const pos = tokenPos();
         const value = tokenValue();
@@ -1373,7 +1583,7 @@ function createParser(code, options = {}) {
         const optional = parseOptional(Token.Question);
         let type;
         if (parseOptional(Token.Colon)) {
-            type = parseExpression();
+            type = parseMixedParameterConstraint();
         }
         return {
             kind: SyntaxKind.FunctionParameter,
@@ -2032,11 +2242,31 @@ function createParser(code, options = {}) {
                     start = tokenPos();
                     while (parseOptional(Token.Whitespace))
                         ;
-                    if (parseOptional(Token.Star)) {
+                    if (!parseOptional(Token.Star)) {
+                        break;
+                    }
+                    if (!inCodeFence) {
                         parseOptional(Token.Whitespace);
                         start = tokenPos();
                         break;
                     }
+                    // If we are in a code fence we want to preserve the leading whitespace
+                    // except for the first space after the star which is used as indentation.
+                    const whitespaceStart = tokenPos();
+                    parseOptional(Token.Whitespace);
+                    // This `min` handles the case when there is no whitespace after the
+                    // star e.g. a case like this:
+                    //
+                    // /**
+                    //  *```
+                    //  *foo-bar
+                    //  *```
+                    //  */
+                    //
+                    // Not having space after the star isn't idiomatic, but we support this.
+                    // `whitespaceStart + 1` strips the first space before `foo-bar` if there
+                    // is a space after the star (the idiomatic case).
+                    start = Math.min(whitespaceStart + 1, tokenPos());
                     break;
                 case Token.EndOfFile:
                     break loop;
@@ -2555,6 +2785,8 @@ export function visitChildren(node, cb) {
                 visitEach(cb, node.arguments));
         case SyntaxKind.DecoratorExpression:
             return visitNode(cb, node.target) || visitEach(cb, node.arguments);
+        case SyntaxKind.CallExpression:
+            return visitNode(cb, node.target) || visitEach(cb, node.arguments);
         case SyntaxKind.DirectiveExpression:
             return visitNode(cb, node.target) || visitEach(cb, node.arguments);
         case SyntaxKind.ImportStatement:
@@ -2604,7 +2836,10 @@ export function visitChildren(node, cb) {
             return (visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
+                visitEach(cb, node.members) ||
                 visitNode(cb, node.extends));
+        case SyntaxKind.ScalarConstructor:
+            return visitNode(cb, node.id) || visitEach(cb, node.parameters);
         case SyntaxKind.UnionStatement:
             return (visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
@@ -2622,6 +2857,8 @@ export function visitChildren(node, cb) {
             return (visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitNode(cb, node.value));
+        case SyntaxKind.ConstStatement:
+            return visitNode(cb, node.id) || visitNode(cb, node.value) || visitNode(cb, node.type);
         case SyntaxKind.DecoratorDeclarationStatement:
             return (visitEach(cb, node.modifiers) ||
                 visitNode(cb, node.id) ||
@@ -2638,6 +2875,8 @@ export function visitChildren(node, cb) {
             return visitNode(cb, node.target) || visitEach(cb, node.arguments);
         case SyntaxKind.ValueOfExpression:
             return visitNode(cb, node.target);
+        case SyntaxKind.TypeOfExpression:
+            return visitNode(cb, node.target);
         case SyntaxKind.TupleExpression:
             return visitEach(cb, node.values);
         case SyntaxKind.UnionExpression:
@@ -2707,6 +2946,14 @@ export function visitChildren(node, cb) {
             return visitNode(cb, node.head) || visitEach(cb, node.spans);
         case SyntaxKind.StringTemplateSpan:
             return visitNode(cb, node.expression) || visitNode(cb, node.literal);
+        case SyntaxKind.ObjectLiteral:
+            return visitEach(cb, node.properties);
+        case SyntaxKind.ObjectLiteralProperty:
+            return visitNode(cb, node.id) || visitNode(cb, node.value);
+        case SyntaxKind.ObjectLiteralSpreadProperty:
+            return visitNode(cb, node.target);
+        case SyntaxKind.ArrayLiteral:
+            return visitEach(cb, node.values);
         // no children for the rest of these.
         case SyntaxKind.StringTemplateHead:
         case SyntaxKind.StringTemplateMiddle:
@@ -2756,6 +3003,21 @@ function visitEach(cb, nodes) {
     }
     return;
 }
+export function getNodeAtPositionDetail(script, position, filter) {
+    const node = getNodeAtPosition(script, position, filter);
+    if (!node)
+        return undefined;
+    const char = script.file.text.charCodeAt(position);
+    const preChar = position >= 0 ? script.file.text.charCodeAt(position - 1) : NaN;
+    const nextChar = position < script.file.text.length ? script.file.text.charCodeAt(position + 1) : NaN;
+    return {
+        node,
+        position,
+        preChar,
+        nextChar,
+        char,
+    };
+}
 export function getNodeAtPosition(script, position, filter = (node) => true) {
     return visit(script);
     function visit(node) {
@@ -2852,6 +3114,26 @@ export function getIdentifierContext(id) {
         case SyntaxKind.TemplateArgument:
             kind = IdentifierKind.TemplateArgument;
             break;
+        case SyntaxKind.ObjectLiteralProperty:
+            kind = IdentifierKind.ObjectLiteralProperty;
+            break;
+        case SyntaxKind.ModelProperty:
+            switch (node.parent?.kind) {
+                case SyntaxKind.ModelExpression:
+                    kind = IdentifierKind.ModelExpressionProperty;
+                    break;
+                case SyntaxKind.ModelStatement:
+                    kind = IdentifierKind.ModelStatementProperty;
+                    break;
+                default:
+                    compilerAssert("false", "ModelProperty with unexpected parent kind.");
+                    kind =
+                        id.parent.id === id
+                            ? IdentifierKind.Declaration
+                            : IdentifierKind.Other;
+                    break;
+            }
+            break;
         default:
             kind =
                 id.parent.id === id