@typespec/prettier-plugin-typespec 0.51.0-dev.1 → 0.52.0-dev.0

package/dist/index.js

@@ -42,56 +42,61 @@ var SyntaxKind;
     SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
     SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
     SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
-    SyntaxKind[SyntaxKind["ExternKeyword"] = 35] = "ExternKeyword";
-    SyntaxKind[SyntaxKind["VoidKeyword"] = 36] = "VoidKeyword";
-    SyntaxKind[SyntaxKind["NeverKeyword"] = 37] = "NeverKeyword";
-    SyntaxKind[SyntaxKind["UnknownKeyword"] = 38] = "UnknownKeyword";
-    SyntaxKind[SyntaxKind["ValueOfExpression"] = 39] = "ValueOfExpression";
-    SyntaxKind[SyntaxKind["TypeReference"] = 40] = "TypeReference";
-    SyntaxKind[SyntaxKind["ProjectionReference"] = 41] = "ProjectionReference";
-    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 42] = "TemplateParameterDeclaration";
-    SyntaxKind[SyntaxKind["EmptyStatement"] = 43] = "EmptyStatement";
-    SyntaxKind[SyntaxKind["InvalidStatement"] = 44] = "InvalidStatement";
-    SyntaxKind[SyntaxKind["LineComment"] = 45] = "LineComment";
-    SyntaxKind[SyntaxKind["BlockComment"] = 46] = "BlockComment";
-    SyntaxKind[SyntaxKind["Doc"] = 47] = "Doc";
-    SyntaxKind[SyntaxKind["DocText"] = 48] = "DocText";
-    SyntaxKind[SyntaxKind["DocParamTag"] = 49] = "DocParamTag";
-    SyntaxKind[SyntaxKind["DocReturnsTag"] = 50] = "DocReturnsTag";
-    SyntaxKind[SyntaxKind["DocErrorsTag"] = 51] = "DocErrorsTag";
-    SyntaxKind[SyntaxKind["DocTemplateTag"] = 52] = "DocTemplateTag";
-    SyntaxKind[SyntaxKind["DocUnknownTag"] = 53] = "DocUnknownTag";
-    SyntaxKind[SyntaxKind["Projection"] = 54] = "Projection";
-    SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 55] = "ProjectionParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 56] = "ProjectionModelSelector";
-    SyntaxKind[SyntaxKind["ProjectionModelPropertySelector"] = 57] = "ProjectionModelPropertySelector";
-    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 58] = "ProjectionOperationSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 59] = "ProjectionUnionSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 60] = "ProjectionUnionVariantSelector";
-    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 61] = "ProjectionInterfaceSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 62] = "ProjectionEnumSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 63] = "ProjectionEnumMemberSelector";
-    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 64] = "ProjectionExpressionStatement";
-    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 65] = "ProjectionIfExpression";
-    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 66] = "ProjectionBlockExpression";
-    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 67] = "ProjectionMemberExpression";
-    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 68] = "ProjectionLogicalExpression";
-    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 69] = "ProjectionEqualityExpression";
-    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 70] = "ProjectionUnaryExpression";
-    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 71] = "ProjectionRelationalExpression";
-    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 72] = "ProjectionArithmeticExpression";
-    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 73] = "ProjectionCallExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 74] = "ProjectionLambdaExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 75] = "ProjectionLambdaParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 76] = "ProjectionModelExpression";
-    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 77] = "ProjectionModelProperty";
-    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 78] = "ProjectionModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 79] = "ProjectionSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 80] = "ProjectionTupleExpression";
-    SyntaxKind[SyntaxKind["ProjectionStatement"] = 81] = "ProjectionStatement";
-    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 82] = "ProjectionDecoratorReferenceExpression";
-    SyntaxKind[SyntaxKind["Return"] = 83] = "Return";
-    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 84] = "JsNamespaceDeclaration";
+    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
+    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
+    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
+    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
+    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
+    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
+    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
+    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
+    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
+    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
+    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
+    SyntaxKind[SyntaxKind["ProjectionReference"] = 46] = "ProjectionReference";
+    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 47] = "TemplateParameterDeclaration";
+    SyntaxKind[SyntaxKind["EmptyStatement"] = 48] = "EmptyStatement";
+    SyntaxKind[SyntaxKind["InvalidStatement"] = 49] = "InvalidStatement";
+    SyntaxKind[SyntaxKind["LineComment"] = 50] = "LineComment";
+    SyntaxKind[SyntaxKind["BlockComment"] = 51] = "BlockComment";
+    SyntaxKind[SyntaxKind["Doc"] = 52] = "Doc";
+    SyntaxKind[SyntaxKind["DocText"] = 53] = "DocText";
+    SyntaxKind[SyntaxKind["DocParamTag"] = 54] = "DocParamTag";
+    SyntaxKind[SyntaxKind["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["ProjectionOperationSelector"] = 63] = "ProjectionOperationSelector";
+    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 64] = "ProjectionUnionSelector";
+    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 65] = "ProjectionUnionVariantSelector";
+    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 66] = "ProjectionInterfaceSelector";
+    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 67] = "ProjectionEnumSelector";
+    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 68] = "ProjectionEnumMemberSelector";
+    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 69] = "ProjectionExpressionStatement";
+    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 70] = "ProjectionIfExpression";
+    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 71] = "ProjectionBlockExpression";
+    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 72] = "ProjectionMemberExpression";
+    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 73] = "ProjectionLogicalExpression";
+    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 74] = "ProjectionEqualityExpression";
+    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 75] = "ProjectionUnaryExpression";
+    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 76] = "ProjectionRelationalExpression";
+    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 77] = "ProjectionArithmeticExpression";
+    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 78] = "ProjectionCallExpression";
+    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 79] = "ProjectionLambdaExpression";
+    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 80] = "ProjectionLambdaParameterDeclaration";
+    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 81] = "ProjectionModelExpression";
+    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 82] = "ProjectionModelProperty";
+    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 83] = "ProjectionModelSpreadProperty";
+    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 84] = "ProjectionSpreadProperty";
+    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 85] = "ProjectionTupleExpression";
+    SyntaxKind[SyntaxKind["ProjectionStatement"] = 86] = "ProjectionStatement";
+    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 87] = "ProjectionDecoratorReferenceExpression";
+    SyntaxKind[SyntaxKind["Return"] = 88] = "Return";
+    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 89] = "JsNamespaceDeclaration";
 })(SyntaxKind || (SyntaxKind = {}));
 var IdentifierKind;
 (function (IdentifierKind) {
@@ -911,6 +916,12 @@ const diagnostics = {
             default: "Projections are experimental - your code will need to change as this feature evolves.",
         },
     },
+    "non-literal-string-template": {
+        severity: "error",
+        messages: {
+            default: "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.",
+        },
+    },
     /**
      * Binder
      */
@@ -3288,107 +3299,110 @@ var Token;
     Token[Token["Identifier"] = 3] = "Identifier";
     Token[Token["NumericLiteral"] = 4] = "NumericLiteral";
     Token[Token["StringLiteral"] = 5] = "StringLiteral";
+    Token[Token["StringTemplateHead"] = 6] = "StringTemplateHead";
+    Token[Token["StringTemplateMiddle"] = 7] = "StringTemplateMiddle";
+    Token[Token["StringTemplateTail"] = 8] = "StringTemplateTail";
     // Add new tokens above if they don't fit any of the categories below
     ///////////////////////////////////////////////////////////////
     // Trivia
-    /**@internal */ Token[Token["__StartTrivia"] = 6] = "__StartTrivia";
-    Token[Token["SingleLineComment"] = 6] = "SingleLineComment";
-    Token[Token["MultiLineComment"] = 7] = "MultiLineComment";
-    Token[Token["NewLine"] = 8] = "NewLine";
-    Token[Token["Whitespace"] = 9] = "Whitespace";
-    Token[Token["ConflictMarker"] = 10] = "ConflictMarker";
+    /**@internal */ Token[Token["__StartTrivia"] = 9] = "__StartTrivia";
+    Token[Token["SingleLineComment"] = 9] = "SingleLineComment";
+    Token[Token["MultiLineComment"] = 10] = "MultiLineComment";
+    Token[Token["NewLine"] = 11] = "NewLine";
+    Token[Token["Whitespace"] = 12] = "Whitespace";
+    Token[Token["ConflictMarker"] = 13] = "ConflictMarker";
     // Add new trivia above
-    /** @internal */ Token[Token["__EndTrivia"] = 11] = "__EndTrivia";
+    /** @internal */ Token[Token["__EndTrivia"] = 14] = "__EndTrivia";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
     // Doc comment content
-    /** @internal */ Token[Token["__StartDocComment"] = 11] = "__StartDocComment";
-    Token[Token["DocText"] = 11] = "DocText";
-    Token[Token["DocCodeSpan"] = 12] = "DocCodeSpan";
-    Token[Token["DocCodeFenceDelimiter"] = 13] = "DocCodeFenceDelimiter";
-    /** @internal */ Token[Token["__EndDocComment"] = 14] = "__EndDocComment";
+    /** @internal */ Token[Token["__StartDocComment"] = 14] = "__StartDocComment";
+    Token[Token["DocText"] = 14] = "DocText";
+    Token[Token["DocCodeSpan"] = 15] = "DocCodeSpan";
+    Token[Token["DocCodeFenceDelimiter"] = 16] = "DocCodeFenceDelimiter";
+    /** @internal */ Token[Token["__EndDocComment"] = 17] = "__EndDocComment";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
     // Punctuation
-    /** @internal */ Token[Token["__StartPunctuation"] = 14] = "__StartPunctuation";
-    Token[Token["OpenBrace"] = 14] = "OpenBrace";
-    Token[Token["CloseBrace"] = 15] = "CloseBrace";
-    Token[Token["OpenParen"] = 16] = "OpenParen";
-    Token[Token["CloseParen"] = 17] = "CloseParen";
-    Token[Token["OpenBracket"] = 18] = "OpenBracket";
-    Token[Token["CloseBracket"] = 19] = "CloseBracket";
-    Token[Token["Dot"] = 20] = "Dot";
-    Token[Token["Ellipsis"] = 21] = "Ellipsis";
-    Token[Token["Semicolon"] = 22] = "Semicolon";
-    Token[Token["Comma"] = 23] = "Comma";
-    Token[Token["LessThan"] = 24] = "LessThan";
-    Token[Token["GreaterThan"] = 25] = "GreaterThan";
-    Token[Token["Equals"] = 26] = "Equals";
-    Token[Token["Ampersand"] = 27] = "Ampersand";
-    Token[Token["Bar"] = 28] = "Bar";
-    Token[Token["Question"] = 29] = "Question";
-    Token[Token["Colon"] = 30] = "Colon";
-    Token[Token["ColonColon"] = 31] = "ColonColon";
-    Token[Token["At"] = 32] = "At";
-    Token[Token["AtAt"] = 33] = "AtAt";
-    Token[Token["Hash"] = 34] = "Hash";
-    Token[Token["Star"] = 35] = "Star";
-    Token[Token["ForwardSlash"] = 36] = "ForwardSlash";
-    Token[Token["Plus"] = 37] = "Plus";
-    Token[Token["Hyphen"] = 38] = "Hyphen";
-    Token[Token["Exclamation"] = 39] = "Exclamation";
-    Token[Token["LessThanEquals"] = 40] = "LessThanEquals";
-    Token[Token["GreaterThanEquals"] = 41] = "GreaterThanEquals";
-    Token[Token["AmpsersandAmpersand"] = 42] = "AmpsersandAmpersand";
-    Token[Token["BarBar"] = 43] = "BarBar";
-    Token[Token["EqualsEquals"] = 44] = "EqualsEquals";
-    Token[Token["ExclamationEquals"] = 45] = "ExclamationEquals";
-    Token[Token["EqualsGreaterThan"] = 46] = "EqualsGreaterThan";
+    /** @internal */ Token[Token["__StartPunctuation"] = 17] = "__StartPunctuation";
+    Token[Token["OpenBrace"] = 17] = "OpenBrace";
+    Token[Token["CloseBrace"] = 18] = "CloseBrace";
+    Token[Token["OpenParen"] = 19] = "OpenParen";
+    Token[Token["CloseParen"] = 20] = "CloseParen";
+    Token[Token["OpenBracket"] = 21] = "OpenBracket";
+    Token[Token["CloseBracket"] = 22] = "CloseBracket";
+    Token[Token["Dot"] = 23] = "Dot";
+    Token[Token["Ellipsis"] = 24] = "Ellipsis";
+    Token[Token["Semicolon"] = 25] = "Semicolon";
+    Token[Token["Comma"] = 26] = "Comma";
+    Token[Token["LessThan"] = 27] = "LessThan";
+    Token[Token["GreaterThan"] = 28] = "GreaterThan";
+    Token[Token["Equals"] = 29] = "Equals";
+    Token[Token["Ampersand"] = 30] = "Ampersand";
+    Token[Token["Bar"] = 31] = "Bar";
+    Token[Token["Question"] = 32] = "Question";
+    Token[Token["Colon"] = 33] = "Colon";
+    Token[Token["ColonColon"] = 34] = "ColonColon";
+    Token[Token["At"] = 35] = "At";
+    Token[Token["AtAt"] = 36] = "AtAt";
+    Token[Token["Hash"] = 37] = "Hash";
+    Token[Token["Star"] = 38] = "Star";
+    Token[Token["ForwardSlash"] = 39] = "ForwardSlash";
+    Token[Token["Plus"] = 40] = "Plus";
+    Token[Token["Hyphen"] = 41] = "Hyphen";
+    Token[Token["Exclamation"] = 42] = "Exclamation";
+    Token[Token["LessThanEquals"] = 43] = "LessThanEquals";
+    Token[Token["GreaterThanEquals"] = 44] = "GreaterThanEquals";
+    Token[Token["AmpsersandAmpersand"] = 45] = "AmpsersandAmpersand";
+    Token[Token["BarBar"] = 46] = "BarBar";
+    Token[Token["EqualsEquals"] = 47] = "EqualsEquals";
+    Token[Token["ExclamationEquals"] = 48] = "ExclamationEquals";
+    Token[Token["EqualsGreaterThan"] = 49] = "EqualsGreaterThan";
     // Add new punctuation above
-    /** @internal */ Token[Token["__EndPunctuation"] = 47] = "__EndPunctuation";
+    /** @internal */ Token[Token["__EndPunctuation"] = 50] = "__EndPunctuation";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
     // Statement keywords
-    /** @internal */ Token[Token["__StartKeyword"] = 47] = "__StartKeyword";
-    /** @internal */ Token[Token["__StartStatementKeyword"] = 47] = "__StartStatementKeyword";
-    Token[Token["ImportKeyword"] = 47] = "ImportKeyword";
-    Token[Token["ModelKeyword"] = 48] = "ModelKeyword";
-    Token[Token["ScalarKeyword"] = 49] = "ScalarKeyword";
-    Token[Token["NamespaceKeyword"] = 50] = "NamespaceKeyword";
-    Token[Token["UsingKeyword"] = 51] = "UsingKeyword";
-    Token[Token["OpKeyword"] = 52] = "OpKeyword";
-    Token[Token["EnumKeyword"] = 53] = "EnumKeyword";
-    Token[Token["AliasKeyword"] = 54] = "AliasKeyword";
-    Token[Token["IsKeyword"] = 55] = "IsKeyword";
-    Token[Token["InterfaceKeyword"] = 56] = "InterfaceKeyword";
-    Token[Token["UnionKeyword"] = 57] = "UnionKeyword";
-    Token[Token["ProjectionKeyword"] = 58] = "ProjectionKeyword";
-    Token[Token["ElseKeyword"] = 59] = "ElseKeyword";
-    Token[Token["IfKeyword"] = 60] = "IfKeyword";
-    Token[Token["DecKeyword"] = 61] = "DecKeyword";
-    Token[Token["FnKeyword"] = 62] = "FnKeyword";
-    Token[Token["ValueOfKeyword"] = 63] = "ValueOfKeyword";
+    /** @internal */ Token[Token["__StartKeyword"] = 50] = "__StartKeyword";
+    /** @internal */ Token[Token["__StartStatementKeyword"] = 50] = "__StartStatementKeyword";
+    Token[Token["ImportKeyword"] = 50] = "ImportKeyword";
+    Token[Token["ModelKeyword"] = 51] = "ModelKeyword";
+    Token[Token["ScalarKeyword"] = 52] = "ScalarKeyword";
+    Token[Token["NamespaceKeyword"] = 53] = "NamespaceKeyword";
+    Token[Token["UsingKeyword"] = 54] = "UsingKeyword";
+    Token[Token["OpKeyword"] = 55] = "OpKeyword";
+    Token[Token["EnumKeyword"] = 56] = "EnumKeyword";
+    Token[Token["AliasKeyword"] = 57] = "AliasKeyword";
+    Token[Token["IsKeyword"] = 58] = "IsKeyword";
+    Token[Token["InterfaceKeyword"] = 59] = "InterfaceKeyword";
+    Token[Token["UnionKeyword"] = 60] = "UnionKeyword";
+    Token[Token["ProjectionKeyword"] = 61] = "ProjectionKeyword";
+    Token[Token["ElseKeyword"] = 62] = "ElseKeyword";
+    Token[Token["IfKeyword"] = 63] = "IfKeyword";
+    Token[Token["DecKeyword"] = 64] = "DecKeyword";
+    Token[Token["FnKeyword"] = 65] = "FnKeyword";
+    Token[Token["ValueOfKeyword"] = 66] = "ValueOfKeyword";
     // Add new statement keyword above
-    /** @internal */ Token[Token["__EndStatementKeyword"] = 64] = "__EndStatementKeyword";
+    /** @internal */ Token[Token["__EndStatementKeyword"] = 67] = "__EndStatementKeyword";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__StartModifierKeyword"] = 64] = "__StartModifierKeyword";
-    Token[Token["ExternKeyword"] = 64] = "ExternKeyword";
-    /** @internal */ Token[Token["__EndModifierKeyword"] = 65] = "__EndModifierKeyword";
+    /** @internal */ Token[Token["__StartModifierKeyword"] = 67] = "__StartModifierKeyword";
+    Token[Token["ExternKeyword"] = 67] = "ExternKeyword";
+    /** @internal */ Token[Token["__EndModifierKeyword"] = 68] = "__EndModifierKeyword";
     ///////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////
     // Other keywords
-    Token[Token["ExtendsKeyword"] = 65] = "ExtendsKeyword";
-    Token[Token["TrueKeyword"] = 66] = "TrueKeyword";
-    Token[Token["FalseKeyword"] = 67] = "FalseKeyword";
-    Token[Token["ReturnKeyword"] = 68] = "ReturnKeyword";
-    Token[Token["VoidKeyword"] = 69] = "VoidKeyword";
-    Token[Token["NeverKeyword"] = 70] = "NeverKeyword";
-    Token[Token["UnknownKeyword"] = 71] = "UnknownKeyword";
+    Token[Token["ExtendsKeyword"] = 68] = "ExtendsKeyword";
+    Token[Token["TrueKeyword"] = 69] = "TrueKeyword";
+    Token[Token["FalseKeyword"] = 70] = "FalseKeyword";
+    Token[Token["ReturnKeyword"] = 71] = "ReturnKeyword";
+    Token[Token["VoidKeyword"] = 72] = "VoidKeyword";
+    Token[Token["NeverKeyword"] = 73] = "NeverKeyword";
+    Token[Token["UnknownKeyword"] = 74] = "UnknownKeyword";
     // Add new non-statement keyword above
-    /** @internal */ Token[Token["__EndKeyword"] = 72] = "__EndKeyword";
+    /** @internal */ Token[Token["__EndKeyword"] = 75] = "__EndKeyword";
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__Count"] = 72] = "__Count";
+    /** @internal */ Token[Token["__Count"] = 75] = "__Count";
 })(Token || (Token = {}));
 /** @internal */
 const TokenDisplay = getTokenDisplayTable([
@@ -3400,6 +3414,9 @@ const TokenDisplay = getTokenDisplayTable([
     [Token.ConflictMarker, "conflict marker"],
     [Token.NumericLiteral, "numeric literal"],
     [Token.StringLiteral, "string literal"],
+    [Token.StringTemplateHead, "string template head"],
+    [Token.StringTemplateMiddle, "string template middle"],
+    [Token.StringTemplateTail, "string template tail"],
     [Token.NewLine, "newline"],
     [Token.Whitespace, "whitespace"],
     [Token.DocCodeFenceDelimiter, "doc code fence delimiter"],
@@ -3547,6 +3564,9 @@ function createScanner(source, diagnosticHandler) {
         scan,
         scanRange,
         scanDoc,
+        reScanStringTemplate,
+        findTripleQuotedStringIndent,
+        unindentAndUnescapeTripleQuotedString,
         eof,
         getTokenText,
         getTokenValue,
@@ -3560,7 +3580,10 @@ function createScanner(source, diagnosticHandler) {
     function getTokenValue() {
         switch (token) {
             case Token.StringLiteral:
-                return getStringTokenValue();
+            case Token.StringTemplateHead:
+            case Token.StringTemplateMiddle:
+            case Token.StringTemplateTail:
+                return getStringTokenValue(token, tokenFlags);
             case Token.Identifier:
                 return getIdentifierTokenValue();
             default:
@@ -3684,8 +3707,8 @@ function createScanner(source, diagnosticHandler) {
                     return lookAhead(1) === 124 /* CharCode.Bar */ ? next(Token.BarBar, 2) : next(Token.Bar);
                 case 34 /* CharCode.DoubleQuote */:
                     return lookAhead(1) === 34 /* CharCode.DoubleQuote */ && lookAhead(2) === 34 /* CharCode.DoubleQuote */
-                        ? scanTripleQuotedString()
-                        : scanString();
+                        ? scanString(TokenFlags.TripleQuoted)
+                        : scanString(TokenFlags.None);
                 case 33 /* CharCode.Exclamation */:
                     return lookAhead(1) === 61 /* CharCode.Equals */
                         ? next(Token.ExclamationEquals, 2)
@@ -3759,6 +3782,11 @@ function createScanner(source, diagnosticHandler) {
         }
         return (token = Token.EndOfFile);
     }
+    function reScanStringTemplate(lastTokenFlags) {
+        position = tokenPosition;
+        tokenFlags = TokenFlags.None;
+        return scanStringTemplateSpan(lastTokenFlags);
+    }
     function scanRange(range, callback) {
         const savedPosition = position;
         const savedEndPosition = endPosition;
@@ -3808,10 +3836,10 @@ function createScanner(source, diagnosticHandler) {
         const codePoint = input.codePointAt(position);
         return (token = next(t, utf16CodeUnits(codePoint)));
     }
-    function error(report) {
+    function error(report, pos, end) {
         const diagnostic = createDiagnostic({
             ...report,
-            target: { file, pos: tokenPosition, end: position },
+            target: { file, pos: pos !== null && pos !== void 0 ? pos : tokenPosition, end: end !== null && end !== void 0 ? end : position },
         });
         diagnosticHandler(diagnostic);
     }
@@ -3903,8 +3931,22 @@ function createScanner(source, diagnosticHandler) {
         }
         return unterminated(Token.DocCodeSpan);
     }
-    function scanString() {
-        position++; // consume '"'
+    function scanString(tokenFlags) {
+        if (tokenFlags & TokenFlags.TripleQuoted) {
+            position += 3; // consume '"""'
+        }
+        else {
+            position++; // consume '"'
+        }
+        return scanStringLiteralLike(tokenFlags, Token.StringTemplateHead, Token.StringLiteral);
+    }
+    function scanStringTemplateSpan(tokenFlags) {
+        position++; // consume '{'
+        return scanStringLiteralLike(tokenFlags, Token.StringTemplateMiddle, Token.StringTemplateTail);
+    }
+    function scanStringLiteralLike(requestedTokenFlags, template, tail) {
+        const multiLine = requestedTokenFlags & TokenFlags.TripleQuoted;
+        tokenFlags = requestedTokenFlags;
         loop: for (; !eof(); position++) {
             const ch = input.charCodeAt(position);
             switch (ch) {
@@ -3916,35 +3958,69 @@ function createScanner(source, diagnosticHandler) {
                     }
                     continue;
                 case 34 /* CharCode.DoubleQuote */:
-                    position++;
-                    return (token = Token.StringLiteral);
+                    if (multiLine) {
+                        if (lookAhead(1) === 34 /* CharCode.DoubleQuote */ && lookAhead(2) === 34 /* CharCode.DoubleQuote */) {
+                            position += 3;
+                            token = tail;
+                            return tail;
+                        }
+                        else {
+                            continue;
+                        }
+                    }
+                    else {
+                        position++;
+                        token = tail;
+                        return tail;
+                    }
+                case 36 /* CharCode.$ */:
+                    if (lookAhead(1) === 123 /* CharCode.OpenBrace */) {
+                        position += 2;
+                        token = template;
+                        return template;
+                    }
+                    continue;
                 case 13 /* CharCode.CarriageReturn */:
                 case 10 /* CharCode.LineFeed */:
-                    break loop;
+                    if (multiLine) {
+                        continue;
+                    }
+                    else {
+                        break loop;
+                    }
             }
         }
-        return unterminated(Token.StringLiteral);
-    }
-    function scanTripleQuotedString() {
-        tokenFlags |= TokenFlags.TripleQuoted;
-        position += 3; // consume '"""'
-        for (; !eof(); position++) {
-            if (input.charCodeAt(position) === 34 /* CharCode.DoubleQuote */ &&
-                lookAhead(1) === 34 /* CharCode.DoubleQuote */ &&
-                lookAhead(2) === 34 /* CharCode.DoubleQuote */) {
-                position += 3;
-                return (token = Token.StringLiteral);
-            }
+        return unterminated(tail);
+    }
+    function getStringLiteralOffsetStart(token, tokenFlags) {
+        switch (token) {
+            case Token.StringLiteral:
+            case Token.StringTemplateHead:
+                return tokenFlags & TokenFlags.TripleQuoted ? 3 : 1; // """ or "
+            default:
+                return 1; // {
         }
-        return unterminated(Token.StringLiteral);
     }
-    function getStringTokenValue() {
-        const quoteLength = tokenFlags & TokenFlags.TripleQuoted ? 3 : 1;
-        const start = tokenPosition + quoteLength;
-        const end = tokenFlags & TokenFlags.Unterminated ? position : position - quoteLength;
-        if (tokenFlags & TokenFlags.TripleQuoted) {
-            return unindentAndUnescapeTripleQuotedString(start, end);
+    function getStringLiteralOffsetEnd(token, tokenFlags) {
+        switch (token) {
+            case Token.StringLiteral:
+            case Token.StringTemplateTail:
+                return tokenFlags & TokenFlags.TripleQuoted ? 3 : 1; // """ or "
+            default:
+                return 2; // ${
         }
+    }
+    function getStringTokenValue(token, tokenFlags) {
+        if (tokenFlags & TokenFlags.TripleQuoted) {
+            const start = tokenPosition;
+            const end = position;
+            const [indentationStart, indentationEnd] = findTripleQuotedStringIndent(start, end);
+            return unindentAndUnescapeTripleQuotedString(start, end, indentationStart, indentationEnd, token, tokenFlags);
+        }
+        const startOffset = getStringLiteralOffsetStart(token, tokenFlags);
+        const endOffset = getStringLiteralOffsetEnd(token, tokenFlags);
+        const start = tokenPosition + startOffset;
+        const end = tokenFlags & TokenFlags.Unterminated ? position : position - endOffset;
         if (tokenFlags & TokenFlags.Escaped) {
             return unescapeString(start, end);
         }
@@ -3961,21 +4037,8 @@ function createScanner(source, diagnosticHandler) {
         }
         return text;
     }
-    function unindentAndUnescapeTripleQuotedString(start, end) {
-        // ignore leading whitespace before required initial line break
-        while (start < end && isWhiteSpaceSingleLine(input.charCodeAt(start))) {
-            start++;
-        }
-        // remove required initial line break
-        if (isLineBreak(input.charCodeAt(start))) {
-            if (isCrlf(start, start, end)) {
-                start++;
-            }
-            start++;
-        }
-        else {
-            error({ code: "no-new-line-start-triple-quote" });
-        }
+    function findTripleQuotedStringIndent(start, end) {
+        end = end - 3; // Remove the """
         // remove whitespace before closing delimiter and record it as required
         // indentation for all lines
         const indentationEnd = end;
@@ -3985,7 +4048,7 @@ function createScanner(source, diagnosticHandler) {
         const indentationStart = end;
         // remove required final line break
         if (isLineBreak(input.charCodeAt(end - 1))) {
-            if (isCrlf(end - 2, start, end)) {
+            if (isCrlf(end - 2, 0, end)) {
                 end--;
             }
             end--;
@@ -3993,13 +4056,61 @@ function createScanner(source, diagnosticHandler) {
         else {
             error({ code: "no-new-line-end-triple-quote" });
         }
+        return [indentationStart, indentationEnd];
+    }
+    function unindentAndUnescapeTripleQuotedString(start, end, indentationStart, indentationEnd, token, tokenFlags) {
+        const startOffset = getStringLiteralOffsetStart(token, tokenFlags);
+        const endOffset = getStringLiteralOffsetEnd(token, tokenFlags);
+        start = start + startOffset;
+        end = tokenFlags & TokenFlags.Unterminated ? end : end - endOffset;
+        if (token === Token.StringLiteral || token === Token.StringTemplateHead) {
+            // ignore leading whitespace before required initial line break
+            while (start < end && isWhiteSpaceSingleLine(input.charCodeAt(start))) {
+                start++;
+            }
+            // remove required initial line break
+            if (isLineBreak(input.charCodeAt(start))) {
+                if (isCrlf(start, start, end)) {
+                    start++;
+                }
+                start++;
+            }
+            else {
+                error({ code: "no-new-line-start-triple-quote" });
+            }
+        }
+        if (token === Token.StringLiteral || token === Token.StringTemplateTail) {
+            while (end > start && isWhiteSpaceSingleLine(input.charCodeAt(end - 1))) {
+                end--;
+            }
+            // remove required final line break
+            if (isLineBreak(input.charCodeAt(end - 1))) {
+                if (isCrlf(end - 2, start, end)) {
+                    end--;
+                }
+                end--;
+            }
+            else {
+                error({ code: "no-new-line-end-triple-quote" });
+            }
+        }
+        let skipUnindentOnce = false;
+        // We are resuming from the middle of a line so we want to keep text as it is from there.
+        if (token === Token.StringTemplateMiddle || token === Token.StringTemplateTail) {
+            skipUnindentOnce = true;
+        }
         // remove required matching indentation from each line and unescape in the
         // process of doing so
         let result = "";
         let pos = start;
         while (pos < end) {
-            // skip indentation at start of line
-            start = skipMatchingIndentation(pos, end, indentationStart, indentationEnd);
+            if (skipUnindentOnce) {
+                skipUnindentOnce = false;
+            }
+            else {
+                // skip indentation at start of line
+                start = skipMatchingIndentation(pos, end, indentationStart, indentationEnd);
+            }
             let ch;
             while (pos < end && !isLineBreak((ch = input.charCodeAt(pos)))) {
                 if (ch !== 92 /* CharCode.Backslash */) {
@@ -4008,7 +4119,7 @@ function createScanner(source, diagnosticHandler) {
                 }
                 result += input.substring(start, pos);
                 if (pos === end - 1) {
-                    error({ code: "invalid-escape-sequence" });
+                    error({ code: "invalid-escape-sequence" }, pos, pos);
                     pos++;
                 }
                 else {
@@ -4069,7 +4180,7 @@ function createScanner(source, diagnosticHandler) {
                 continue;
             }
             if (pos === end - 1) {
-                error({ code: "invalid-escape-sequence" });
+                error({ code: "invalid-escape-sequence" }, pos, pos);
                 break;
             }
             result += input.substring(start, pos);
@@ -4093,10 +4204,12 @@ function createScanner(source, diagnosticHandler) {
                 return '"';
             case 92 /* CharCode.Backslash */:
                 return "\\";
+            case 36 /* CharCode.$ */:
+                return "$";
             case 96 /* CharCode.Backtick */:
                 return "`";
             default:
-                error({ code: "invalid-escape-sequence" });
+                error({ code: "invalid-escape-sequence" }, pos, pos + 2);
                 return String.fromCharCode(ch);
         }
     }
@@ -4423,6 +4536,10 @@ function needsParens(path, options) {
     // eslint-disable-next-line deprecation/deprecation
     const node = path.getValue();
     switch (node.kind) {
+        case SyntaxKind.ValueOfExpression:
+            return (parent.kind === SyntaxKind.UnionExpression ||
+                parent.kind === SyntaxKind.ArrayExpression ||
+                parent.kind === SyntaxKind.IntersectionExpression);
         case SyntaxKind.IntersectionExpression:
             return (parent.kind === SyntaxKind.UnionExpression || parent.kind === SyntaxKind.ArrayExpression);
         case SyntaxKind.UnionExpression:
@@ -4633,6 +4750,12 @@ path, options, print) {
             return "";
         case SyntaxKind.EmptyStatement:
             return "";
+        case SyntaxKind.StringTemplateExpression:
+            return printStringTemplateExpression(path, options, print);
+        case SyntaxKind.StringTemplateSpan:
+        case SyntaxKind.StringTemplateHead:
+        case SyntaxKind.StringTemplateMiddle:
+        case SyntaxKind.StringTemplateTail:
         case SyntaxKind.JsSourceFile:
         case SyntaxKind.JsNamespaceDeclaration:
         case SyntaxKind.InvalidStatement:
@@ -5484,6 +5607,17 @@ function printProjectionLambdaParameterDeclaration(path, options, print) {
 function printReturnExpression(path, options, print) {
     return ["return ", path.call(print, "value")];
 }
+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;
+}
 function printItemList(path, options, print, key) {
     return join(", ", path.map(print, key));
 }
@@ -6539,6 +6673,8 @@ function createParser(code, options = {}) {
                     return parseReferenceExpression();
                 case Token.StringLiteral:
                     return parseStringLiteral();
+                case Token.StringTemplateHead:
+                    return parseStringTemplateExpression();
                 case Token.TrueKeyword:
                 case Token.FalseKeyword:
                     return parseBooleanLiteral();
@@ -6636,6 +6772,90 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseStringTemplateExpression() {
+        const pos = tokenPos();
+        const head = parseStringTemplateHead();
+        const spans = parseStringTemplateSpans(head.tokenFlags);
+        const last = spans[spans.length - 1];
+        if (head.tokenFlags & TokenFlags.TripleQuoted) {
+            const [indentationsStart, indentationEnd] = scanner.findTripleQuotedStringIndent(last.literal.pos, last.literal.end);
+            mutate(head).value = scanner.unindentAndUnescapeTripleQuotedString(head.pos, head.end, indentationsStart, indentationEnd, Token.StringTemplateHead, head.tokenFlags);
+            for (const span of spans) {
+                mutate(span.literal).value = scanner.unindentAndUnescapeTripleQuotedString(span.literal.pos, span.literal.end, indentationsStart, indentationEnd, span === last ? Token.StringTemplateTail : Token.StringTemplateMiddle, head.tokenFlags);
+            }
+        }
+        return {
+            kind: SyntaxKind.StringTemplateExpression,
+            head,
+            spans,
+            ...finishNode(pos),
+        };
+    }
+    function parseStringTemplateHead() {
+        const pos = tokenPos();
+        const flags = tokenFlags();
+        const text = flags & TokenFlags.TripleQuoted ? "" : tokenValue();
+        parseExpected(Token.StringTemplateHead);
+        return {
+            kind: SyntaxKind.StringTemplateHead,
+            value: text,
+            tokenFlags: flags,
+            ...finishNode(pos),
+        };
+    }
+    function parseStringTemplateSpans(tokenFlags) {
+        const list = [];
+        let node;
+        do {
+            node = parseTemplateTypeSpan(tokenFlags);
+            list.push(node);
+        } while (node.literal.kind === SyntaxKind.StringTemplateMiddle);
+        return list;
+    }
+    function parseTemplateTypeSpan(tokenFlags) {
+        const pos = tokenPos();
+        const expression = parseExpression();
+        const literal = parseLiteralOfTemplateSpan(tokenFlags);
+        return {
+            kind: SyntaxKind.StringTemplateSpan,
+            literal,
+            expression,
+            ...finishNode(pos),
+        };
+    }
+    function parseLiteralOfTemplateSpan(headTokenFlags) {
+        const pos = tokenPos();
+        const flags = tokenFlags();
+        const text = flags & TokenFlags.TripleQuoted ? "" : tokenValue();
+        if (token() === Token.CloseBrace) {
+            nextStringTemplateToken(headTokenFlags);
+            return parseTemplateMiddleOrTemplateTail();
+        }
+        else {
+            parseExpected(Token.StringTemplateTail);
+            return {
+                kind: SyntaxKind.StringTemplateTail,
+                value: text,
+                tokenFlags: flags,
+                ...finishNode(pos),
+            };
+        }
+    }
+    function parseTemplateMiddleOrTemplateTail() {
+        const pos = tokenPos();
+        const flags = tokenFlags();
+        const text = flags & TokenFlags.TripleQuoted ? "" : tokenValue();
+        const kind = token() === Token.StringTemplateMiddle
+            ? SyntaxKind.StringTemplateMiddle
+            : SyntaxKind.StringTemplateTail;
+        nextToken();
+        return {
+            kind,
+            value: text,
+            tokenFlags: flags,
+            ...finishNode(pos),
+        };
+    }
     function parseNumericLiteral() {
         const pos = tokenPos();
         const valueAsString = tokenValue();
@@ -7467,7 +7687,7 @@ function createParser(code, options = {}) {
     /**
      * Parses a documentation tag.
      *
-     * @see <a href="https://microsoft.github.io/typespec/language-basics/documentation#tsdoc-doc-comments">TypeSpec documentation docs</a>
+     * @see <a href="https://microsoft.github.io/typespec/language-basics/documentation#doc-comments">TypeSpec documentation docs</a>
      */
     function parseDocTag() {
         const pos = tokenPos();
@@ -7612,6 +7832,9 @@ function createParser(code, options = {}) {
         // NOTE: trivia tokens are always significant in doc comments.
         scanner.scanDoc();
     }
+    function nextStringTemplateToken(tokenFlags) {
+        scanner.reScanStringTemplate(tokenFlags);
+    }
     function createMissingIdentifier() {
         const pos = tokenPos();
         previousTokenEnd = pos;
@@ -8089,7 +8312,14 @@ function visitChildren(node, cb) {
         case SyntaxKind.DocErrorsTag:
         case SyntaxKind.DocUnknownTag:
             return visitNode(cb, node.tagName) || visitEach(cb, node.content);
+        case SyntaxKind.StringTemplateExpression:
+            return visitNode(cb, node.head) || visitEach(cb, node.spans);
+        case SyntaxKind.StringTemplateSpan:
+            return visitNode(cb, node.expression) || visitNode(cb, node.literal);
         // no children for the rest of these.
+        case SyntaxKind.StringTemplateHead:
+        case SyntaxKind.StringTemplateMiddle:
+        case SyntaxKind.StringTemplateTail:
         case SyntaxKind.StringLiteral:
         case SyntaxKind.NumericLiteral:
         case SyntaxKind.BooleanLiteral: