@typespec/prettier-plugin-typespec 0.57.0-dev.1 → 0.58.0-dev.0

package/dist/index.js

@@ -302,6 +302,7 @@ const diagnostics = {
             default: "Invalid identifier.",
             tag: "Invalid tag name. Use backticks around code if this was not meant to be a tag.",
             param: "Invalid parameter name.",
+            prop: "Invalid property name.",
             templateParam: "Invalid template parameter name.",
         },
     },
@@ -1168,51 +1169,52 @@ var SyntaxKind;
     SyntaxKind[SyntaxKind["Doc"] = 52] = "Doc";
     SyntaxKind[SyntaxKind["DocText"] = 53] = "DocText";
     SyntaxKind[SyntaxKind["DocParamTag"] = 54] = "DocParamTag";
-    SyntaxKind[SyntaxKind["DocReturnsTag"] = 55] = "DocReturnsTag";
-    SyntaxKind[SyntaxKind["DocErrorsTag"] = 56] = "DocErrorsTag";
-    SyntaxKind[SyntaxKind["DocTemplateTag"] = 57] = "DocTemplateTag";
-    SyntaxKind[SyntaxKind["DocUnknownTag"] = 58] = "DocUnknownTag";
-    SyntaxKind[SyntaxKind["Projection"] = 59] = "Projection";
-    SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 60] = "ProjectionParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 61] = "ProjectionModelSelector";
-    SyntaxKind[SyntaxKind["ProjectionModelPropertySelector"] = 62] = "ProjectionModelPropertySelector";
-    SyntaxKind[SyntaxKind["ProjectionScalarSelector"] = 63] = "ProjectionScalarSelector";
-    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 64] = "ProjectionOperationSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 65] = "ProjectionUnionSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 66] = "ProjectionUnionVariantSelector";
-    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 67] = "ProjectionInterfaceSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 68] = "ProjectionEnumSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 69] = "ProjectionEnumMemberSelector";
-    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 70] = "ProjectionExpressionStatement";
-    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 71] = "ProjectionIfExpression";
-    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 72] = "ProjectionBlockExpression";
-    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 73] = "ProjectionMemberExpression";
-    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 74] = "ProjectionLogicalExpression";
-    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 75] = "ProjectionEqualityExpression";
-    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 76] = "ProjectionUnaryExpression";
-    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 77] = "ProjectionRelationalExpression";
-    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 78] = "ProjectionArithmeticExpression";
-    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 79] = "ProjectionCallExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 80] = "ProjectionLambdaExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 81] = "ProjectionLambdaParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 82] = "ProjectionModelExpression";
-    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 83] = "ProjectionModelProperty";
-    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 84] = "ProjectionModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 85] = "ProjectionSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 86] = "ProjectionTupleExpression";
-    SyntaxKind[SyntaxKind["ProjectionStatement"] = 87] = "ProjectionStatement";
-    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 88] = "ProjectionDecoratorReferenceExpression";
-    SyntaxKind[SyntaxKind["Return"] = 89] = "Return";
-    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 90] = "JsNamespaceDeclaration";
-    SyntaxKind[SyntaxKind["TemplateArgument"] = 91] = "TemplateArgument";
-    SyntaxKind[SyntaxKind["TypeOfExpression"] = 92] = "TypeOfExpression";
-    SyntaxKind[SyntaxKind["ObjectLiteral"] = 93] = "ObjectLiteral";
-    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 94] = "ObjectLiteralProperty";
-    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 95] = "ObjectLiteralSpreadProperty";
-    SyntaxKind[SyntaxKind["ArrayLiteral"] = 96] = "ArrayLiteral";
-    SyntaxKind[SyntaxKind["ConstStatement"] = 97] = "ConstStatement";
-    SyntaxKind[SyntaxKind["CallExpression"] = 98] = "CallExpression";
-    SyntaxKind[SyntaxKind["ScalarConstructor"] = 99] = "ScalarConstructor";
+    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) {
@@ -2474,6 +2476,8 @@ function createScanner(source, diagnosticHandler) {
                 return getStringTokenValue(token, tokenFlags);
             case Token.Identifier:
                 return getIdentifierTokenValue();
+            case Token.DocText:
+                return getDocTextValue();
             default:
                 return getTokenText();
         }
@@ -2639,6 +2643,9 @@ function createScanner(source, diagnosticHandler) {
                 // fallthrough
                 case 10 /* CharCode.LineFeed */:
                     return next(Token.NewLine);
+                case 92 /* CharCode.Backslash */:
+                    tokenFlags |= TokenFlags.Escaped;
+                    return position === endPosition - 1 ? next(Token.DocText) : next(Token.DocText, 2);
                 case 32 /* CharCode.Space */:
                 case 9 /* CharCode.Tab */:
                 case 11 /* CharCode.VerticalTab */:
@@ -2933,6 +2940,39 @@ function createScanner(source, diagnosticHandler) {
         }
         return text;
     }
+    function getDocTextValue() {
+        if (tokenFlags & TokenFlags.Escaped) {
+            let start = tokenPosition;
+            const end = position;
+            let result = "";
+            let pos = start;
+            while (pos < end) {
+                const ch = input.charCodeAt(pos);
+                if (ch !== 92 /* CharCode.Backslash */) {
+                    pos++;
+                    continue;
+                }
+                if (pos === end - 1) {
+                    break;
+                }
+                result += input.substring(start, pos);
+                switch (input.charCodeAt(pos + 1)) {
+                    case 64 /* CharCode.At */:
+                        result += "@";
+                        break;
+                    default:
+                        result += input.substring(pos, pos + 2);
+                }
+                pos += 2;
+                start = pos;
+            }
+            result += input.substring(start, end);
+            return result;
+        }
+        else {
+            return input.substring(tokenPosition, position);
+        }
+    }
     function findTripleQuotedStringIndent(start, end) {
         end = end - 3; // Remove the """
         // remove whitespace before closing delimiter and record it as required
@@ -3102,6 +3142,8 @@ function createScanner(source, diagnosticHandler) {
                 return "\\";
             case 36 /* CharCode.$ */:
                 return "$";
+            case 64 /* CharCode.At */:
+                return "@";
             case 96 /* CharCode.Backtick */:
                 return "`";
             default:
@@ -3707,8 +3749,8 @@ function createParser(code, options = {}) {
     function parseInterfaceStatement(pos, decorators) {
         parseExpected(Token.InterfaceKeyword);
         const id = parseIdentifier();
-        const templateParameters = parseTemplateParameterList();
-        let extendList = [];
+        const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
+        let extendList = createEmptyList();
         if (token() === Token.ExtendsKeyword) {
             nextToken();
             extendList = parseList(ListKind.Heritage, parseReferenceExpression);
@@ -3717,21 +3759,23 @@ function createParser(code, options = {}) {
             error({ code: "token-expected", format: { token: "'extends' or '{'" } });
             nextToken();
         }
-        const operations = parseList(ListKind.InterfaceMembers, (pos, decorators) => parseOperationStatement(pos, decorators, true));
+        const { items: operations, range: bodyRange } = parseList(ListKind.InterfaceMembers, (pos, decorators) => parseOperationStatement(pos, decorators, true));
         return {
             kind: SyntaxKind.InterfaceStatement,
             id,
             templateParameters,
+            templateParametersRange,
             operations,
-            extends: extendList,
+            bodyRange,
+            extends: extendList.items,
             decorators,
             ...finishNode(pos),
         };
     }
     function parseTemplateParameterList() {
-        const list = parseOptionalList(ListKind.TemplateParameters, parseTemplateParameter);
+        const detail = parseOptionalList(ListKind.TemplateParameters, parseTemplateParameter);
         let setDefault = false;
-        for (const item of list) {
+        for (const item of detail.items) {
             if (!item.default && setDefault) {
                 error({ code: "default-required", target: item });
                 continue;
@@ -3740,17 +3784,18 @@ function createParser(code, options = {}) {
                 setDefault = true;
             }
         }
-        return list;
+        return detail;
     }
     function parseUnionStatement(pos, decorators) {
         parseExpected(Token.UnionKeyword);
         const id = parseIdentifier();
-        const templateParameters = parseTemplateParameterList();
-        const options = parseList(ListKind.UnionVariants, parseUnionVariant);
+        const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
+        const { items: options } = parseList(ListKind.UnionVariants, parseUnionVariant);
         return {
             kind: SyntaxKind.UnionStatement,
             id,
             templateParameters,
+            templateParametersRange,
             decorators,
             options,
             ...finishNode(pos),
@@ -3816,7 +3861,7 @@ function createParser(code, options = {}) {
             parseExpected(Token.OpKeyword);
         }
         const id = parseIdentifier();
-        const templateParameters = parseTemplateParameterList();
+        const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
         // Make sure the next token is one that is expected
         const token = expectTokenIsOneOf(Token.OpenParen, Token.IsKeyword);
         // Check if we're parsing a declaration or reuse of another operation
@@ -3850,6 +3895,7 @@ function createParser(code, options = {}) {
             kind: SyntaxKind.OperationStatement,
             id,
             templateParameters,
+            templateParametersRange,
             signature,
             decorators,
             ...finishNode(pos),
@@ -3857,10 +3903,11 @@ function createParser(code, options = {}) {
     }
     function parseOperationParameters() {
         const pos = tokenPos();
-        const properties = parseList(ListKind.OperationParameters, parseModelPropertyOrSpread);
+        const { items: properties, range: bodyRange } = parseList(ListKind.OperationParameters, parseModelPropertyOrSpread);
         const parameters = {
             kind: SyntaxKind.ModelExpression,
             properties,
+            bodyRange,
             ...finishNode(pos),
         };
         return parameters;
@@ -3868,22 +3915,22 @@ function createParser(code, options = {}) {
     function parseModelStatement(pos, decorators) {
         parseExpected(Token.ModelKeyword);
         const id = parseIdentifier();
-        const templateParameters = parseTemplateParameterList();
+        const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
         expectTokenIsOneOf(Token.OpenBrace, Token.Equals, Token.ExtendsKeyword, Token.IsKeyword);
         const optionalExtends = parseOptionalModelExtends();
         const optionalIs = optionalExtends ? undefined : parseOptionalModelIs();
-        let properties = [];
+        let propDetail = createEmptyList();
         if (optionalIs) {
             const tok = expectTokenIsOneOf(Token.Semicolon, Token.OpenBrace);
             if (tok === Token.Semicolon) {
                 nextToken();
             }
             else {
-                properties = parseList(ListKind.ModelProperties, parseModelPropertyOrSpread);
+                propDetail = parseList(ListKind.ModelProperties, parseModelPropertyOrSpread);
             }
         }
         else {
-            properties = parseList(ListKind.ModelProperties, parseModelPropertyOrSpread);
+            propDetail = parseList(ListKind.ModelProperties, parseModelPropertyOrSpread);
         }
         return {
             kind: SyntaxKind.ModelStatement,
@@ -3891,8 +3938,10 @@ function createParser(code, options = {}) {
             extends: optionalExtends,
             is: optionalIs,
             templateParameters,
+            templateParametersRange,
             decorators,
-            properties,
+            properties: propDetail.items,
+            bodyRange: propDetail.range,
             ...finishNode(pos),
         };
     }
@@ -4024,15 +4073,17 @@ function createParser(code, options = {}) {
     function parseScalarStatement(pos, decorators) {
         parseExpected(Token.ScalarKeyword);
         const id = parseIdentifier();
-        const templateParameters = parseTemplateParameterList();
+        const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
         const optionalExtends = parseOptionalScalarExtends();
-        const members = parseScalarMembers();
+        const { items: members, range: bodyRange } = parseScalarMembers();
         return {
             kind: SyntaxKind.ScalarStatement,
             id,
             templateParameters,
+            templateParametersRange,
             extends: optionalExtends,
             members,
+            bodyRange,
             decorators,
             ...finishNode(pos),
         };
@@ -4046,7 +4097,7 @@ function createParser(code, options = {}) {
     function parseScalarMembers() {
         if (token() === Token.Semicolon) {
             nextToken();
-            return [];
+            return createEmptyList();
         }
         else {
             return parseList(ListKind.ScalarMembers, parseScalarMember);
@@ -4056,7 +4107,7 @@ function createParser(code, options = {}) {
         reportInvalidDecorators(decorators, "scalar member");
         parseExpected(Token.InitKeyword);
         const id = parseIdentifier();
-        const parameters = parseFunctionParameters();
+        const { items: parameters } = parseFunctionParameters();
         return {
             kind: SyntaxKind.ScalarConstructor,
             id,
@@ -4067,7 +4118,7 @@ function createParser(code, options = {}) {
     function parseEnumStatement(pos, decorators) {
         parseExpected(Token.EnumKeyword);
         const id = parseIdentifier();
-        const members = parseList(ListKind.EnumMembers, parseEnumMemberOrSpread);
+        const { items: members } = parseList(ListKind.EnumMembers, parseEnumMemberOrSpread);
         return {
             kind: SyntaxKind.EnumStatement,
             id,
@@ -4121,7 +4172,7 @@ function createParser(code, options = {}) {
     function parseAliasStatement(pos) {
         parseExpected(Token.AliasKeyword);
         const id = parseIdentifier();
-        const templateParameters = parseTemplateParameterList();
+        const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
         parseExpected(Token.Equals);
         const value = parseExpression();
         parseExpected(Token.Semicolon);
@@ -4129,6 +4180,7 @@ function createParser(code, options = {}) {
             kind: SyntaxKind.AliasStatement,
             id,
             templateParameters,
+            templateParametersRange,
             value,
             ...finishNode(pos),
         };
@@ -4268,17 +4320,18 @@ function createParser(code, options = {}) {
         const pos = tokenPos();
         const target = parseIdentifierOrMemberExpression(message);
         if (token() === Token.OpenParen) {
+            const { items: args } = parseList(ListKind.FunctionArguments, parseExpression);
             return {
                 kind: SyntaxKind.CallExpression,
                 target,
-                arguments: parseList(ListKind.FunctionArguments, parseExpression),
+                arguments: args,
                 ...finishNode(pos),
             };
         }
         return parseReferenceExpressionInternal(target, pos);
     }
     function parseReferenceExpressionInternal(target, pos) {
-        const args = parseOptionalList(ListKind.TemplateArguments, parseTemplateArgument);
+        const { items: args } = parseOptionalList(ListKind.TemplateArguments, parseTemplateArgument);
         return {
             kind: SyntaxKind.TypeReference,
             target,
@@ -4329,29 +4382,31 @@ function createParser(code, options = {}) {
         // `@<missing identifier>` applied to `model Foo`, and not as `@model`
         // applied to invalid statement `Foo`.
         const target = parseIdentifierOrMemberExpression(undefined, false);
-        const args = parseOptionalList(ListKind.DecoratorArguments, parseExpression);
+        const { items: args } = parseOptionalList(ListKind.DecoratorArguments, parseExpression);
         if (args.length === 0) {
             error({ code: "augment-decorator-target" });
+            const emptyList = createEmptyList();
             return {
                 kind: SyntaxKind.AugmentDecoratorStatement,
                 target,
                 targetType: {
                     kind: SyntaxKind.TypeReference,
                     target: createMissingIdentifier(),
-                    arguments: [],
+                    arguments: emptyList.items,
                     ...finishNode(pos),
                 },
-                arguments: [],
+                arguments: args,
                 ...finishNode(pos),
             };
         }
         let [targetEntity, ...decoratorArgs] = args;
         if (targetEntity.kind !== SyntaxKind.TypeReference) {
             error({ code: "augment-decorator-target", target: targetEntity });
+            const emptyList = createEmptyList();
             targetEntity = {
                 kind: SyntaxKind.TypeReference,
                 target: createMissingIdentifier(),
-                arguments: [],
+                arguments: emptyList.items,
                 ...finishNode(pos),
             };
         }
@@ -4383,7 +4438,7 @@ function createParser(code, options = {}) {
         // `@<missing identifier>` applied to `model Foo`, and not as `@model`
         // applied to invalid statement `Foo`.
         const target = parseIdentifierOrMemberExpression(undefined, false);
-        const args = parseOptionalList(ListKind.DecoratorArguments, parseExpression);
+        const { items: args } = parseOptionalList(ListKind.DecoratorArguments, parseExpression);
         return {
             kind: SyntaxKind.DecoratorExpression,
             arguments: args,
@@ -4567,7 +4622,7 @@ function createParser(code, options = {}) {
     }
     function parseTupleExpression() {
         const pos = tokenPos();
-        const values = parseList(ListKind.Tuple, parseExpression);
+        const { items: values } = parseList(ListKind.Tuple, parseExpression);
         return {
             kind: SyntaxKind.TupleExpression,
             values,
@@ -4576,25 +4631,27 @@ function createParser(code, options = {}) {
     }
     function parseModelExpression() {
         const pos = tokenPos();
-        const properties = parseList(ListKind.ModelProperties, parseModelPropertyOrSpread);
+        const { items: properties, range: bodyRange } = parseList(ListKind.ModelProperties, parseModelPropertyOrSpread);
         return {
             kind: SyntaxKind.ModelExpression,
             properties,
+            bodyRange,
             ...finishNode(pos),
         };
     }
     function parseObjectLiteral() {
         const pos = tokenPos();
-        const properties = parseList(ListKind.ObjectLiteralProperties, parseObjectLiteralPropertyOrSpread);
+        const { items: properties, range: bodyRange } = parseList(ListKind.ObjectLiteralProperties, parseObjectLiteralPropertyOrSpread);
         return {
             kind: SyntaxKind.ObjectLiteral,
             properties,
+            bodyRange,
             ...finishNode(pos),
         };
     }
     function parseArrayLiteral() {
         const pos = tokenPos();
-        const values = parseList(ListKind.ArrayLiteral, parseExpression);
+        const { items: values } = parseList(ListKind.ArrayLiteral, parseExpression);
         return {
             kind: SyntaxKind.ArrayLiteral,
             values,
@@ -4767,7 +4824,8 @@ function createParser(code, options = {}) {
         const modifierFlags = modifiersToFlags(modifiers);
         parseExpected(Token.DecKeyword);
         const id = parseIdentifier();
-        let [target, ...parameters] = parseFunctionParameters();
+        const allParamListDetail = parseFunctionParameters();
+        let [target, ...parameters] = allParamListDetail.items;
         if (target === undefined) {
             error({ code: "decorator-decl-target", target: { pos, end: previousTokenEnd } });
             target = {
@@ -4797,7 +4855,7 @@ function createParser(code, options = {}) {
         const modifierFlags = modifiersToFlags(modifiers);
         parseExpected(Token.FnKeyword);
         const id = parseIdentifier();
-        const parameters = parseFunctionParameters();
+        const { items: parameters } = parseFunctionParameters();
         let returnType;
         if (parseOptional(Token.Colon)) {
             returnType = parseExpression();
@@ -4816,7 +4874,7 @@ function createParser(code, options = {}) {
     function parseFunctionParameters() {
         const parameters = parseList(ListKind.FunctionParameters, parseFunctionParameter);
         let foundOptional = false;
-        for (const [index, item] of parameters.entries()) {
+        for (const [index, item] of parameters.items.entries()) {
             if (!item.optional && foundOptional) {
                 error({ code: "required-parameter-first", target: item });
                 continue;
@@ -4827,7 +4885,7 @@ function createParser(code, options = {}) {
             if (item.rest && item.optional) {
                 error({ code: "rest-parameter-required", target: item });
             }
-            if (item.rest && index !== parameters.length - 1) {
+            if (item.rest && index !== parameters.items.length - 1) {
                 error({ code: "rest-parameter-last", target: item });
             }
         }
@@ -4919,7 +4977,7 @@ function createParser(code, options = {}) {
         }
         let parameters;
         if (token() === Token.OpenParen) {
-            parameters = parseList(ListKind.ProjectionParameter, parseProjectionParameter);
+            parameters = parseList(ListKind.ProjectionParameter, parseProjectionParameter).items;
         }
         else {
             parameters = [];
@@ -5141,7 +5199,7 @@ function createParser(code, options = {}) {
                     kind: SyntaxKind.ProjectionCallExpression,
                     callKind: "method",
                     target: expr,
-                    arguments: parseList(ListKind.CallArguments, parseProjectionExpression),
+                    arguments: parseList(ListKind.CallArguments, parseProjectionExpression).items,
                     ...finishNode(pos),
                 };
             }
@@ -5224,7 +5282,7 @@ function createParser(code, options = {}) {
     }
     function parseProjectionLambdaOrParenthesizedExpression() {
         const pos = tokenPos();
-        const exprs = parseList(ListKind.ProjectionExpression, parseProjectionExpression);
+        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 = [];
@@ -5275,7 +5333,7 @@ function createParser(code, options = {}) {
     }
     function parseProjectionModelExpression() {
         const pos = tokenPos();
-        const properties = parseList(ListKind.ModelProperties, parseProjectionModelPropertyOrSpread);
+        const { items: properties } = parseList(ListKind.ModelProperties, parseProjectionModelPropertyOrSpread);
         return {
             kind: SyntaxKind.ProjectionModelExpression,
             properties,
@@ -5349,7 +5407,7 @@ function createParser(code, options = {}) {
     }
     function parseProjectionTupleExpression() {
         const pos = tokenPos();
-        const values = parseList(ListKind.Tuple, parseProjectionExpression);
+        const { items: values } = parseList(ListKind.Tuple, parseProjectionExpression);
         return {
             kind: SyntaxKind.ProjectionTupleExpression,
             values,
@@ -5533,6 +5591,12 @@ function createParser(code, options = {}) {
                     }
                     nextToken();
                     break;
+                case Token.DocText:
+                    parts.push(source.substring(start, tokenPos()));
+                    parts.push(tokenValue());
+                    nextToken();
+                    start = tokenPos();
+                    break;
                 default:
                     nextToken();
                     break;
@@ -5562,6 +5626,8 @@ function createParser(code, options = {}) {
                 return parseDocParamLikeTag(pos, tagName, SyntaxKind.DocParamTag, "param");
             case "template":
                 return parseDocParamLikeTag(pos, tagName, SyntaxKind.DocTemplateTag, "templateParam");
+            case "prop":
+                return parseDocPropTag(pos, tagName);
             case "return":
             case "returns":
                 return parseDocSimpleTag(pos, tagName, SyntaxKind.DocReturnsTag);
@@ -5576,9 +5642,7 @@ function createParser(code, options = {}) {
      * For example, `@param` and `@template`.
      */
     function parseDocParamLikeTag(pos, tagName, kind, messageId) {
-        const name = parseDocIdentifier(messageId);
-        parseOptionalHyphenDocParamLikeTag();
-        const content = parseDocContent();
+        const { name, content } = parseDocParamLikeTagInternal(messageId);
         return {
             kind,
             tagName,
@@ -5587,6 +5651,22 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseDocPropTag(pos, tagName) {
+        const { name, content } = parseDocParamLikeTagInternal("prop");
+        return {
+            kind: SyntaxKind.DocPropTag,
+            tagName,
+            propName: name,
+            content,
+            ...finishNode(pos),
+        };
+    }
+    function parseDocParamLikeTagInternal(messageId) {
+        const name = parseDocIdentifier(messageId);
+        parseOptionalHyphenDocParamLikeTag();
+        const content = parseDocContent();
+        return { name, content };
+    }
     /**
      * Handles the optional hyphen in param-like documentation comment tags.
      *
@@ -5711,10 +5791,11 @@ function createParser(code, options = {}) {
     }
     function createMissingTypeReference() {
         const pos = tokenPos();
+        const { items: args } = createEmptyList();
         return {
             kind: SyntaxKind.TypeReference,
             target: createMissingIdentifier(),
-            arguments: [],
+            arguments: args,
             ...finishNode(pos),
         };
     }
@@ -5727,6 +5808,12 @@ function createParser(code, options = {}) {
     function withSymbol(obj) {
         return obj;
     }
+    function createEmptyList(range = { pos: -1, end: -1 }) {
+        return {
+            items: [],
+            range,
+        };
+    }
     /**
      * Parse a delimited list of elements, including the surrounding open and
      * close punctuation
@@ -5743,13 +5830,17 @@ function createParser(code, options = {}) {
      * do not go through here.
      */
     function parseList(kind, parseItem) {
+        const r = createEmptyList();
         if (kind.open !== Token.None) {
-            parseExpected(kind.open);
+            const t = tokenPos();
+            if (parseExpected(kind.open)) {
+                mutate(r.range).pos = t;
+            }
         }
         if (kind.allowEmpty && parseOptional(kind.close)) {
-            return [];
+            mutate(r.range).end = previousTokenEnd;
+            return r;
         }
-        const items = [];
         while (true) {
             const startingPos = tokenPos();
             const { pos, docs, directives, decorators } = parseAnnotations({
@@ -5764,7 +5855,9 @@ function createParser(code, options = {}) {
                 // of file. Note, however, that we must parse a missing element if
                 // there were directives or decorators as we cannot drop those from
                 // the tree.
-                parseExpected(kind.close);
+                if (parseExpected(kind.close)) {
+                    mutate(r.range).end = previousTokenEnd;
+                }
                 break;
             }
             let item;
@@ -5776,12 +5869,13 @@ function createParser(code, options = {}) {
                 mutate(item).docs = docs;
                 mutate(item).directives = directives;
             }
-            items.push(item);
+            r.items.push(item);
             const delimiter = token();
             const delimiterPos = tokenPos();
             if (parseOptionalDelimiter(kind)) {
                 // Delimiter found: check if it's trailing.
                 if (parseOptional(kind.close)) {
+                    mutate(r.range).end = previousTokenEnd;
                     if (!kind.trailingDelimiterIsValid) {
                         error({
                             code: "trailing-token",
@@ -5805,6 +5899,7 @@ function createParser(code, options = {}) {
                 break;
             }
             else if (parseOptional(kind.close)) {
+                mutate(r.range).end = previousTokenEnd;
                 // If a list *is* surrounded by punctuation, then the list ends when we
                 // reach the close token.
                 break;
@@ -5815,7 +5910,9 @@ function createParser(code, options = {}) {
                 // assumption that the closing delimiter is missing. This check is
                 // duplicated from above to preempt the parseExpected(delimeter)
                 // below.
-                parseExpected(kind.close);
+                if (parseExpected(kind.close)) {
+                    mutate(r.range).end = previousTokenEnd;
+                }
                 break;
             }
             else {
@@ -5834,21 +5931,23 @@ function createParser(code, options = {}) {
                 //
                 // Simple repro: `model M { ]` would loop forever without this check.
                 //
-                parseExpected(kind.close);
+                if (parseExpected(kind.close)) {
+                    mutate(r.range).end = previousTokenEnd;
+                }
                 nextToken();
                 // remove the item that was entirely inserted by error recovery.
-                items.pop();
+                r.items.pop();
                 break;
             }
         }
-        return items;
+        return r;
     }
     /**
      * Parse a delimited list with surrounding open and close punctuation if the
      * open token is present. Otherwise, return an empty list.
      */
     function parseOptionalList(kind, parseItem) {
-        return token() === kind.open ? parseList(kind, parseItem) : [];
+        return token() === kind.open ? parseList(kind, parseItem) : createEmptyList();
     }
     function parseOptionalDelimiter(kind) {
         if (parseOptional(kind.delimiter)) {
@@ -6195,6 +6294,8 @@ function visitChildren(node, cb) {
         case SyntaxKind.DocParamTag:
         case SyntaxKind.DocTemplateTag:
             return (visitNode(cb, node.tagName) || visitNode(cb, node.paramName) || visitEach(cb, node.content));
+        case SyntaxKind.DocPropTag:
+            return (visitNode(cb, node.tagName) || visitNode(cb, node.propName) || visitEach(cb, node.content));
         case SyntaxKind.DocReturnsTag:
         case SyntaxKind.DocErrorsTag:
         case SyntaxKind.DocUnknownTag:
@@ -6448,7 +6549,7 @@ function group$1(contents, opts = {}) {
 function dedentToRoot(contents) {
   return align$1(Number.NEGATIVE_INFINITY, contents);
 }
-function markAsRoot(contents) {
+function markAsRoot$1(contents) {
   return align$1({ type: "root" }, contents);
 }
 function dedent(contents) {
@@ -6491,7 +6592,7 @@ var literallineWithoutBreakParent = {
 var line$1 = { type: DOC_TYPE_LINE };
 var softline$1 = { type: DOC_TYPE_LINE, soft: true };
 var hardline$1 = [hardlineWithoutBreakParent, breakParent$1];
-var literalline = [literallineWithoutBreakParent, breakParent$1];
+var literalline$1 = [literallineWithoutBreakParent, breakParent$1];
 var cursor = { type: DOC_TYPE_CURSOR };
 function join$1(separator, docs) {
   const parts = [];
@@ -6902,7 +7003,7 @@ function cleanDocFn(doc) {
 function cleanDoc(doc) {
   return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));
 }
-function replaceEndOfLine(doc, replacement = literalline) {
+function replaceEndOfLine(doc, replacement = literalline$1) {
   return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join$1(replacement, currentDoc.split("\n")) : currentDoc);
 }
 function canBreakFn(doc) {
@@ -7483,7 +7584,7 @@ var builders = {
   line: line$1,
   softline: softline$1,
   hardline: hardline$1,
-  literalline,
+  literalline: literalline$1,
   group: group$1,
   conditionalGroup,
   fill,
@@ -7497,7 +7598,7 @@ var builders = {
   indentIfBreak,
   align: align$1,
   addAlignmentToDoc,
-  markAsRoot,
+  markAsRoot: markAsRoot$1,
   dedentToRoot,
   dedent,
   hardlineWithoutBreakParent,
@@ -7721,7 +7822,7 @@ function needsParens(path, options) {
     }
 }
 
-const { align, breakParent, group, hardline, ifBreak, indent, join, line, softline } = builders;
+const { align, breakParent, group, hardline, ifBreak, indent, join, line, softline, literalline, markAsRoot, } = builders;
 const { isNextLineEmpty } = util;
 /**
  * If the decorators for that node should try to be kept inline.
@@ -7916,6 +8017,7 @@ path, options, print) {
             return printDoc(path, options);
         case SyntaxKind.DocText:
         case SyntaxKind.DocParamTag:
+        case SyntaxKind.DocPropTag:
         case SyntaxKind.DocTemplateTag:
         case SyntaxKind.DocReturnsTag:
         case SyntaxKind.DocErrorsTag:
@@ -8126,7 +8228,8 @@ function printCallOrDecoratorArgs(path, options, print) {
     // })
     const shouldHug = node.arguments.length === 1 &&
         (node.arguments[0].kind === SyntaxKind.ModelExpression ||
-            node.arguments[0].kind === SyntaxKind.StringLiteral);
+            node.arguments[0].kind === SyntaxKind.StringLiteral ||
+            node.arguments[0].kind === SyntaxKind.StringTemplateExpression);
     if (shouldHug) {
         return [
             "(",
@@ -8740,7 +8843,22 @@ function printModifiers(path, options, print) {
 }
 function printStringLiteral(path, options) {
     const node = path.node;
-    return getRawText(node, options);
+    const multiline = isMultiline(node, options);
+    const raw = getRawText(node, options);
+    if (multiline) {
+        const lines = splitLines(raw.slice(3));
+        const whitespaceIndent = lines[lines.length - 1].length - 3;
+        const newLines = trimMultilineString(lines, whitespaceIndent);
+        return [`"""`, indent(markAsRoot(newLines))];
+    }
+    else {
+        return raw;
+    }
+}
+function isMultiline(node, options) {
+    return (options.originalText[node.pos] &&
+        options.originalText[node.pos + 1] === `"` &&
+        options.originalText[node.pos + 2] === `"`);
 }
 function printNumberLiteral(path, options) {
     const node = path.node;
@@ -8878,14 +8996,76 @@ function printReturnExpression(path, options, print) {
 }
 function printStringTemplateExpression(path, options, print) {
     const node = path.node;
-    const content = [
-        getRawText(node.head, options),
-        path.map((span) => {
-            const expression = span.call(print, "expression");
-            return [expression, getRawText(span.node.literal, options)];
-        }, "spans"),
-    ];
-    return content;
+    const multiline = isMultiline(node, options);
+    const rawHead = getRawText(node.head, options);
+    if (multiline) {
+        const lastSpan = node.spans[node.spans.length - 1];
+        const lastLines = splitLines(getRawText(lastSpan.literal, options));
+        const whitespaceIndent = lastLines[lastLines.length - 1].length - 3;
+        const content = [
+            trimMultilineString(splitLines(rawHead.slice(3)), whitespaceIndent),
+            path.map((span) => {
+                const expression = span.call(print, "expression");
+                const spanRawText = getRawText(span.node.literal, options);
+                const spanLines = splitLines(spanRawText);
+                return [
+                    expression,
+                    spanLines[0],
+                    literalline,
+                    trimMultilineString(spanLines.slice(1), whitespaceIndent),
+                ];
+            }, "spans"),
+        ];
+        return [`"""`, indent(markAsRoot([content]))];
+    }
+    else {
+        const content = [
+            rawHead,
+            path.map((span) => {
+                const expression = span.call(print, "expression");
+                return [expression, getRawText(span.node.literal, options)];
+            }, "spans"),
+        ];
+        return content;
+    }
+}
+function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    let pos = 0;
+    while (pos < text.length) {
+        const ch = text.charCodeAt(pos);
+        switch (ch) {
+            case 13 /* CharCode.CarriageReturn */:
+                if (text.charCodeAt(pos + 1) === 10 /* CharCode.LineFeed */) {
+                    lines.push(text.slice(start, pos));
+                    start = pos;
+                    pos++;
+                }
+                else {
+                    lines.push(text.slice(start, pos));
+                    start = pos;
+                }
+                break;
+            case 10 /* CharCode.LineFeed */:
+                lines.push(text.slice(start, pos));
+                start = pos;
+                break;
+        }
+        pos++;
+    }
+    lines.push(text.slice(start));
+    return lines;
+}
+function trimMultilineString(lines, whitespaceIndent) {
+    const newLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        newLines.push(lines[i].slice(whitespaceIndent));
+        if (i < lines.length - 1) {
+            newLines.push(literalline);
+        }
+    }
+    return newLines;
 }
 function printItemList(path, options, print, key) {
     return join(", ", path.map(print, key));