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(