Type Inference for Regular Expressions

src/compiler/core.ts

@@ -1123,6 +1123,12 @@ export function last<T>(array: readonly T[]): T {
     return array[array.length - 1];
 }
 
+/** @internal */
+export function setLast<T>(array: T[], value: T): T {
+    Debug.assert(array.length !== 0);
+    return array[array.length - 1] = value;
+}
+
 /**
  * Returns the only element of an array if it contains only one element, `undefined` otherwise.
  *

src/compiler/diagnosticMessages.json

@@ -1705,10 +1705,6 @@
         "category": "Error",
         "code": 1512
     },
-    "Undetermined character escape.": {
-        "category": "Error",
-        "code": 1513
-    },
     "Expected a capturing group name.": {
         "category": "Error",
         "code": 1514
@@ -1834,6 +1830,10 @@
         "category": "Error",
         "code": 1544
     },
+    "'\\k' is only available outside character class.": {
+        "category": "Error",
+        "code": 1545
+    },
 
     "The types of '{0}' are incompatible between these types.": {
         "category": "Error",

src/compiler/parser.ts

@@ -10689,9 +10689,11 @@ function extractPragmas(pragmas: PragmaPseudoMapEntry[], range: CommentRange, te
                     return; // Missing required argument, don't parse
                 }
                 else if (matchResult) {
-                    const value = matchResult[2] || matchResult[3];
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249
+                    const value = (matchResult[2] || matchResult[3])!;
                     if (arg.captureSpan) {
-                        const startPos = range.pos + matchResult.index + matchResult[1].length + 1;
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249
+                        const startPos = range.pos + matchResult.index + matchResult[1]!.length + 1;
                         argument[arg.name] = {
                             value,
                             pos: startPos,
@@ -10720,14 +10722,16 @@ function extractPragmas(pragmas: PragmaPseudoMapEntry[], range: CommentRange, te
         const multiLinePragmaRegEx = /@(\S+)(\s+(?:\S.*)?)?$/gm; // Defined inline since it uses the "g" flag, which keeps a persistent index (for iterating)
         let multiLineMatch: RegExpExecArray | null; // eslint-disable-line no-restricted-syntax
         while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
-            addPragmaForMatch(pragmas, range, PragmaKindFlags.MultiLine, multiLineMatch);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249
+            addPragmaForMatch(pragmas, range, PragmaKindFlags.MultiLine, multiLineMatch!);
         }
     }
 }
 
 function addPragmaForMatch(pragmas: PragmaPseudoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray) {
     if (!match) return;
-    const name = match[1].toLowerCase() as keyof PragmaPseudoMap; // Technically unsafe cast, but we do it so they below check to make it safe typechecks
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249
+    const name = match[1]!.toLowerCase() as keyof PragmaPseudoMap; // Technically unsafe cast, but we do it so they below check to make it safe typechecks
     const pragma = commentPragmas[name] as PragmaDefinition;
     if (!pragma || !(pragma.kind! & kind)) {
         return;

src/compiler/semver.ts

@@ -331,7 +331,7 @@ function parseHyphen(left: string, right: string, comparators: Comparator[]) {
     return true;
 }
 
-function parseComparator(operator: string, text: string, comparators: Comparator[]) {
+function parseComparator(operator: string | undefined, text: string, comparators: Comparator[]) {
     const result = parsePartial(text);
     if (!result) return false;
 

src/compiler/sourcemap.ts

@@ -391,7 +391,8 @@ export function tryGetSourceMappingURL(lineInfo: LineInfo): string | undefined {
         const line = lineInfo.getLineText(index);
         const comment = sourceMapCommentRegExp.exec(line);
         if (comment) {
-            return comment[1].trimEnd();
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249
+            return comment[1]!.trimEnd();
         }
         // If we see a non-whitespace/map comment-like line, break, to avoid scanning up the entire file
         else if (!line.match(whitespaceOrMapCommentRegExp)) {

src/compiler/transformers/jsx.ts

@@ -619,15 +619,15 @@ export function transformJsx(context: TransformationContext): (x: SourceFile | B
      * See https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
      */
     function decodeEntities(text: string): string {
-        return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {
+        return text.replace(/&(?:#(?:(\d+)|x([\da-fA-F]+))|(\w+));/g, (match, decimal, hex, word) => {
             if (decimal) {
                 return utf16EncodeAsString(parseInt(decimal, 10));
             }
             else if (hex) {
                 return utf16EncodeAsString(parseInt(hex, 16));
             }
             else {
-                const ch = entities.get(word);
+                const ch = entities.get(word || "");
                 // If this is not a valid entity, then just use `match` (replace it with itself, i.e. don't replace)
                 return ch ? utf16EncodeAsString(ch) : match;
             }

src/compiler/types.ts

@@ -13,6 +13,7 @@ import {
     PackageJsonInfo,
     PackageJsonInfoCache,
     Pattern,
+    RegExpAnyString,
     SymlinkCache,
     ThisContainer,
 } from "./_namespaces/ts.js";
@@ -2801,6 +2802,52 @@ export const enum RegularExpressionFlags {
     Modifiers      = IgnoreCase | Multiline | DotAll,
 }
 
+/** @internal */
+export interface RegularExpressionDisjunction {
+    patternUnion?: RegularExpressionPatternUnion;
+    groupNumber?: number;
+    groupName?: string;
+    isInNegativeAssertion?: boolean;
+}
+
+/** @internal */
+export interface RegularExpressionDisjunctionsScope extends Array<RegularExpressionDisjunction> {
+    /** All disjunctions after this index are the ones need to be considered */
+    currentAlternativeIndex: number;
+}
+
+/** @internal */
+export type RegularExpressionAnyString = typeof RegExpAnyString;
+
+/** @internal */
+export type RegularExpressionPatternContent = string | RegularExpressionAnyString | RegularExpressionPatternUnion;
+
+/** @internal */
+export interface RegularExpressionPattern extends Array<RegularExpressionPatternContent> {
+    _regularExpressionPatternBrand: any;
+}
+
+/** @internal */
+export interface RegularExpressionPatternUnion extends Set<string | RegularExpressionPattern> {
+    _regularExpressionPatternUnionBrand: any;
+    isPossiblyUndefined?: boolean;
+    isCharacterClass?: boolean; // For fast path in the checker
+    isCharacterEquivalents?: boolean;
+}
+
+/** @internal */
+export type RegularExpressionReducedContent = string | RegularExpressionAnyString | RegularExpressionReducedUnion | RegularExpressionReducedPattern;
+
+/** @internal */
+export interface RegularExpressionReducedUnion extends Set<string | RegularExpressionReducedPattern> {
+    _regularExpressionReducedUnionBrand: any;
+}
+
+/** @internal */
+export interface RegularExpressionReducedPattern extends Array<string | RegularExpressionAnyString> {
+    _regularExpressionReducedPatternBrand: any;
+}
+
 export interface NoSubstitutionTemplateLiteral extends LiteralExpression, TemplateLiteralLikeNode, Declaration {
     readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
     /** @internal */

src/compiler/utilities.ts

@@ -6063,10 +6063,10 @@ export function hasInvalidEscape(template: TemplateLiteral): boolean {
 // the language service. These characters should be escaped when printing, and if any characters are added,
 // the map below must be updated. Note that this regexp *does not* include the 'delete' character.
 // There is no reason for this other than that JSON.stringify does not handle it either.
-const doubleQuoteEscapedCharsRegExp = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g;
-const singleQuoteEscapedCharsRegExp = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g;
+const doubleQuoteEscapedCharsRegExp: RegExp = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g;
+const singleQuoteEscapedCharsRegExp: RegExp = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g;
 // Template strings preserve simple LF newlines, still encode CRLF (or CR)
-const backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g;
+const backtickQuoteEscapedCharsRegExp: RegExp = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g;
 const escapedCharsMap = new Map(Object.entries({
     "\t": "\\t",
     "\v": "\\v",
@@ -6114,7 +6114,7 @@ export function escapeString(s: string, quoteChar?: CharacterCodes.doubleQuote |
     const escapedCharsRegExp = quoteChar === CharacterCodes.backtick ? backtickQuoteEscapedCharsRegExp :
         quoteChar === CharacterCodes.singleQuote ? singleQuoteEscapedCharsRegExp :
         doubleQuoteEscapedCharsRegExp;
-    return s.replace(escapedCharsRegExp, getReplacement);
+    return s.replace(escapedCharsRegExp, getReplacement as (...args: any[]) => string);
 }
 
 const nonAsciiCharacters = /[^\u0000-\u007F]/g;
@@ -6132,8 +6132,8 @@ export function escapeNonAsciiString(s: string, quoteChar?: CharacterCodes.doubl
 // paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in
 // the language service. These characters should be escaped when printing, and if any characters are added,
 // the map below must be updated.
-const jsxDoubleQuoteEscapedCharsRegExp = /["\u0000-\u001f\u2028\u2029\u0085]/g;
-const jsxSingleQuoteEscapedCharsRegExp = /['\u0000-\u001f\u2028\u2029\u0085]/g;
+const jsxDoubleQuoteEscapedCharsRegExp: RegExp = /["\u0000-\u001f\u2028\u2029\u0085]/g;
+const jsxSingleQuoteEscapedCharsRegExp: RegExp = /['\u0000-\u001f\u2028\u2029\u0085]/g;
 const jsxEscapedCharsMap = new Map(Object.entries({
     '"': """,
     "'": "'",
@@ -6155,7 +6155,7 @@ function getJsxAttributeStringReplacement(c: string) {
 export function escapeJsxAttributeString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote): string {
     const escapedCharsRegExp = quoteChar === CharacterCodes.singleQuote ? jsxSingleQuoteEscapedCharsRegExp :
         jsxDoubleQuoteEscapedCharsRegExp;
-    return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement);
+    return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement as (...args: any[]) => string);
 }
 
 /**

src/harness/fourslashInterfaceImpl.ts

@@ -1224,6 +1224,10 @@ export namespace Completion {
         interfaceEntry("CallableFunction"),
         interfaceEntry("NewableFunction"),
         interfaceEntry("IArguments"),
+        interfaceEntry("StringReplaceCallbackOptions"),
+        interfaceEntry("StringReplaceCallbackIncludeNamedCapturingGroups"),
+        typeEntry("StringReplaceCallbackSignature"),
+        typeEntry("RegExpMatchArray"),
         varEntry("String"),
         interfaceEntry("StringConstructor"),
         varEntry("Boolean"),
@@ -1238,9 +1242,14 @@ export namespace Completion {
         varEntry("Math"),
         varEntry("Date"),
         interfaceEntry("DateConstructor"),
-        interfaceEntry("RegExpMatchArray"),
-        interfaceEntry("RegExpExecArray"),
+        typeEntry("CapturingGroupsArray"),
+        typeEntry("NamedCapturingGroupsObject"),
+        typeEntry("RegExpExecArray"),
+        interfaceEntry("_RegExpExecArray"), // XXX This shouldn't be included
+        interfaceEntry("RegExpIndices"),
         varEntry("RegExp"),
+        interfaceEntry("_RegExp"), // XXX This shouldn't be included
+        interfaceEntry("RegExpFlags"),
         interfaceEntry("RegExpConstructor"),
         varEntry("Error"),
         interfaceEntry("ErrorConstructor"),

src/harness/harnessIO.ts

@@ -1290,7 +1290,8 @@ export namespace TestCaseParser {
 
         let match: RegExpExecArray | null; // eslint-disable-line no-restricted-syntax
         while ((match = optionRegex.exec(content)) !== null) { // eslint-disable-line no-restricted-syntax
-            opts[match[1]] = match[2].trim();
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249
+            opts[match[1]!] = match[2]!.trim();
         }
 
         return opts;
@@ -1327,8 +1328,9 @@ export namespace TestCaseParser {
             else if (testMetaData = optionRegex.exec(line)) {
                 // Comment line, check for global/file @options and record them
                 optionRegex.lastIndex = 0;
-                const metaDataName = testMetaData[1].toLowerCase();
-                currentFileOptions[testMetaData[1]] = testMetaData[2].trim();
+                /* eslint-disable @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249 */
+                const metaDataName = testMetaData[1]!.toLowerCase();
+                currentFileOptions[testMetaData[1]!] = testMetaData[2]!.trim();
                 if (metaDataName !== "filename") {
                     continue;
                 }
@@ -1348,12 +1350,13 @@ export namespace TestCaseParser {
                     // Reset local data
                     currentFileContent = undefined;
                     currentFileOptions = {};
-                    currentFileName = testMetaData[2].trim();
+                    currentFileName = testMetaData[2]!.trim();
                     refs = [];
                 }
                 else {
                     // First metadata marker in the file
-                    currentFileName = testMetaData[2].trim();
+                    currentFileName = testMetaData[2]!.trim();
+                    /* eslint-enable @typescript-eslint/no-unnecessary-type-assertion -- TODO: Remove this line after #60249 */
                     if (currentFileContent && ts.skipTrivia(currentFileContent, 0, /*stopAfterLineBreak*/ false, /*stopAtComments*/ false) !== currentFileContent.length) {
                         throw new Error("Non-comment test content appears before the first '// @Filename' directive");
                     }

src/harness/util.ts

@@ -13,7 +13,7 @@ function createDiagnosticMessageReplacer<R extends (messageArgs: string[], ...ar
     const messageParts = diagnosticMessage.message.split(/\{\d+\}/);
     const regExp = new RegExp(`^(?:${messageParts.map(ts.regExpEscape).join("(.*?)")})$`);
     type Args<R> = R extends (messageArgs: string[], ...args: infer A) => string[] ? A : [];
-    return (text: string, ...args: Args<R>) => text.replace(regExp, (_, ...fixedArgs) => ts.formatStringFromArgs(diagnosticMessage.message, replacer(fixedArgs, ...args)));
+    return (text: string, ...args: Args<R>) => text.replace(regExp, (_, ...fixedArgs) => ts.formatStringFromArgs(diagnosticMessage.message, replacer(fixedArgs as string[], ...args)));
 }
 
 const replaceTypesVersionsMessage = createDiagnosticMessageReplacer(