Fix up all self check errors

microsoft · graphemecluster · Oct 17, 2024 · Nov 4, 2024 · Nov 4, 2024 · Nov 6, 2024
commit 61fc428906e39f2cffed3a7b7df971b41fcad7d5
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -10689,9 +10689,9 @@ function extractPragmas(pragmas: PragmaPseudoMapEntry[], range: CommentRange, te
                     return; // Missing required argument, don't parse
                 }
                 else if (matchResult) {
-                    const value = matchResult[2] || matchResult[3];
+                    const value = (matchResult[2] || matchResult[3])!;
                     if (arg.captureSpan) {
-                        const startPos = range.pos + matchResult.index + matchResult[1].length + 1;
+                        const startPos = range.pos + matchResult.index + matchResult[1]!.length + 1;
                         argument[arg.name] = {
                             value,
                             pos: startPos,
@@ -10718,14 +10718,14 @@ function extractPragmas(pragmas: PragmaPseudoMapEntry[], range: CommentRange, te
 
     if (range.kind === SyntaxKind.MultiLineCommentTrivia) {
         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
+        let multiLineMatch: RegExpExecArray<[string, string, string | undefined]> | null; // eslint-disable-line no-restricted-syntax
         while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
             addPragmaForMatch(pragmas, range, PragmaKindFlags.MultiLine, multiLineMatch);
         }
     }
 }
 
-function addPragmaForMatch(pragmas: PragmaPseudoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray) {
+function addPragmaForMatch(pragmas: PragmaPseudoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray<[string, string, string | undefined]>) {
     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
     const pragma = commentPragmas[name] as PragmaDefinition;

diff --git a/src/compiler/semver.ts b/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;
 

diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
@@ -360,12 +360,12 @@ export function createSourceMapGenerator(host: EmitHost, file: string, sourceRoo
 
 // Sometimes tools can see the following line as a source mapping url comment, so we mangle it a bit (the [M])
 /** @internal */
-export const sourceMapCommentRegExpDontCareLineStart: RegExp = /\/\/[@#] source[M]appingURL=(.+)\r?\n?$/; // eslint-disable-line regexp/no-useless-character-class
+export const sourceMapCommentRegExpDontCareLineStart: RegExp<[string, string]> = /\/\/[@#] source[M]appingURL=(.+)\r?\n?$/; // eslint-disable-line regexp/no-useless-character-class
 /** @internal */
-export const sourceMapCommentRegExp: RegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/; // eslint-disable-line regexp/no-useless-character-class
+export const sourceMapCommentRegExp: RegExp<[string, string]> = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/; // eslint-disable-line regexp/no-useless-character-class
 
 /** @internal */
-export const whitespaceOrMapCommentRegExp: RegExp = /^\s*(\/\/[@#] .*)?$/;
+export const whitespaceOrMapCommentRegExp: RegExp<[string, string | undefined]> = /^\s*(\/\/[@#] .*)?$/;
 
 /** @internal */
 export interface LineInfo {

diff --git a/src/compiler/transformers/jsx.ts b/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;
             }

diff --git a/src/compiler/utilities.ts b/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<[string]> = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g;
+const singleQuoteEscapedCharsRegExp: RegExp<[string]> = /[\\'\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<[string]> = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g;
 const escapedCharsMap = new Map(Object.entries({
     "\t": "\\t",
     "\v": "\\v",
@@ -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<[string]> = /["\u0000-\u001f\u2028\u2029\u0085]/g;
+const jsxSingleQuoteEscapedCharsRegExp: RegExp<[string]> = /['\u0000-\u001f\u2028\u2029\u0085]/g;
 const jsxEscapedCharsMap = new Map(Object.entries({
     '"': "&quot;",
     "'": "&apos;",

diff --git a/src/harness/harnessIO.ts b/src/harness/harnessIO.ts
@@ -1288,7 +1288,7 @@ export namespace TestCaseParser {
     export function extractCompilerSettings(content: string): CompilerSettings {
         const opts: CompilerSettings = {};
 
-        let match: RegExpExecArray | null; // eslint-disable-line no-restricted-syntax
+        let match: RegExpExecArray<[string, string, string]> | 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();
         }
@@ -1319,7 +1319,7 @@ export namespace TestCaseParser {
         let symlinks: vfs.FileSet | undefined;
 
         for (const line of lines) {
-            let testMetaData: RegExpExecArray | null; // eslint-disable-line no-restricted-syntax
+            let testMetaData: RegExpExecArray<[string, string, string]> | null; // eslint-disable-line no-restricted-syntax
             const possiblySymlinks = parseSymlinkFromTest(line, symlinks, vfs.srcFolder);
             if (possiblySymlinks) {
                 symlinks = possiblySymlinks;

diff --git a/src/harness/util.ts b/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(

diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -5249,18 +5249,18 @@ export class ProjectService {
 
                     if (rule.exclude) {
                         for (const exclude of rule.exclude) {
-                            const processedRule = root.replace(rule.match, (...groups: string[]) => {
+                            const processedRule = root.replace(rule.match, (...groups) => {
                                 return exclude.map(groupNumberOrString => {
                                     // RegExp group numbers are 1-based, but the first element in groups
                                     // is actually the original string, so it all works out in the end.
                                     if (typeof groupNumberOrString === "number") {
-                                        if (!isString(groups[groupNumberOrString])) {
+                                        if (!isString((groups as string[])[groupNumberOrString])) {
                                             // Specification was wrong - exclude nothing!
                                             this.logger.info(`Incorrect RegExp specification in safelist rule ${name} - not enough groups`);
                                             // * can't appear in a filename; escape it because it's feeding into a RegExp
                                             return "\\*";
                                         }
-                                        return ProjectService.escapeFilenameForRegex(groups[groupNumberOrString]);
+                                        return ProjectService.escapeFilenameForRegex((groups as string[])[groupNumberOrString]);
                                     }
                                     return groupNumberOrString;
                                 }).join("");

diff --git a/src/services/classifier.ts b/src/services/classifier.ts
@@ -957,7 +957,7 @@ export function getEncodedSyntacticClassifications(cancellationToken: Cancellati
         pushClassification(pos, match[3].length, ClassificationType.jsxSelfClosingTagName); // element name
         pos += match[3].length;
 
-        const attrText = match[4];
+        const attrText = match[4] || "";
         let attrPos = pos;
         while (true) {
             const attrMatch = attributeRegex.exec(attrText);
@@ -991,7 +991,7 @@ export function getEncodedSyntacticClassifications(cancellationToken: Cancellati
             attrPos += attrMatch[6].length;
         }
 
-        pos += match[4].length;
+        pos += attrText.length;
 
         if (pos > attrPos) {
             pushCommentRange(attrPos, pos - attrPos);

diff --git a/src/services/codefixes/fixAddMissingConstraint.ts b/src/services/codefixes/fixAddMissingConstraint.ts
@@ -133,7 +133,7 @@ function addMissingConstraint(changes: textChanges.ChangeTracker, program: Progr
 
 function tryGetConstraintFromDiagnosticMessage(messageText: string | DiagnosticMessageChain) {
     const [, constraint] = flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [];
-    return constraint;
+    return constraint || "";
 }
 
 function tryGetConstraintType(checker: TypeChecker, node: Node) {

diff --git a/src/services/codefixes/fixNaNEquality.ts b/src/services/codefixes/fixNaNEquality.ts
@@ -88,5 +88,5 @@ function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, ar
 
 function getSuggestion(messageText: string | DiagnosticMessageChain) {
     const [, suggestion] = flattenDiagnosticMessageText(messageText, "\n", 0).match(/'(.*)'/) || [];
-    return suggestion;
+    return suggestion || "";
 }
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -3153,7 +3153,7 @@ export function createLanguageService(
                 const firstDescriptorCaptureIndex = 3;
                 Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
 
-                const preamble = matchArray[1];
+                const preamble = matchArray[1]!;
                 const matchPosition = matchArray.index + preamble.length;
 
                 // OK, we have found a match in the file.  This is only an acceptable match if
@@ -3176,7 +3176,7 @@ export function createLanguageService(
                     continue;
                 }
 
-                const message = matchArray[2];
+                const message = matchArray[2]!;
                 result.push({ descriptor, message, position: matchPosition });
             }
         }