@typespec/compiler 0.51.0-dev.8 → 0.51.0

package/dist/src/core/scanner.js

@@ -12,107 +12,110 @@ export 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 */
 export const TokenDisplay = getTokenDisplayTable([
@@ -124,6 +127,9 @@ export 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"],
@@ -274,6 +280,9 @@ export function createScanner(source, diagnosticHandler) {
         scan,
         scanRange,
         scanDoc,
+        reScanStringTemplate,
+        findTripleQuotedStringIndent,
+        unindentAndUnescapeTripleQuotedString,
         eof,
         getTokenText,
         getTokenValue,
@@ -287,7 +296,10 @@ export 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:
@@ -411,8 +423,8 @@ export 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)
@@ -486,6 +498,11 @@ export 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;
@@ -535,10 +552,10 @@ export 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);
     }
@@ -630,8 +647,22 @@ export 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) {
@@ -643,35 +674,69 @@ export 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);
+        return unterminated(tail);
     }
-    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);
-            }
+    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;
+    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) {
-            return unindentAndUnescapeTripleQuotedString(start, end);
+            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);
         }
@@ -688,21 +753,8 @@ export 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;
@@ -712,7 +764,7 @@ export 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--;
@@ -720,13 +772,61 @@ export 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 */) {
@@ -735,7 +835,7 @@ export 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 {
@@ -796,7 +896,7 @@ export 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);
@@ -820,10 +920,12 @@ export 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);
         }
     }