tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/regexp-checker.js

@@ -127,7 +127,7 @@ class RegularExpressionChecker {
         for (const reference of this.groupNameReferences) {
             if (this.groupSpecifiers.has(reference.name))
                 continue;
-            this.error(447 /* Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression */, reference.pos, reference.end - reference.pos, [reference.name]);
+            this.error(445 /* Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression */, reference.pos, reference.end - reference.pos, [reference.name]);
             if (this.groupSpecifiers.size > 0) {
                 const suggestion = getSpellingSuggestion(reference.name, setToArray(this.groupSpecifiers));
                 if (suggestion !== '')
@@ -139,22 +139,36 @@ class RegularExpressionChecker {
             if (escape.value <= this.numberOfCapturingGroups)
                 continue;
             if (this.numberOfCapturingGroups > 0)
-                this.error(448 /* Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression */, escape.pos, escape.end - escape.pos, [String(this.numberOfCapturingGroups)]);
+                this.error(446 /* Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression */, escape.pos, escape.end - escape.pos, [String(this.numberOfCapturingGroups)]);
             else
-                this.error(449 /* Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression */, escape.pos, escape.end - escape.pos, noArgs);
+                this.error(447 /* Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression */, escape.pos, escape.end - escape.pos, noArgs);
         }
         return this.numberOfCapturingGroups;
     }
     // Disjunction ::= Alternative ('|' Alternative)*
     scanDisjunction(isInGroup) {
+        // The names any alternative defines. One alternative matches, so in a group they join the
+        // enclosing alternative's scope: `(?:(?<a>x))(?<a>z)` defines `a` twice.
+        let disjunctionNames;
         for (;;) {
             this.namedCapturingGroups.push(new Set());
             this.scanAlternative(isInGroup);
-            this.namedCapturingGroups.pop();
+            const alternativeNames = this.namedCapturingGroups.pop();
+            if (alternativeNames.size > 0) {
+                if (disjunctionNames === undefined)
+                    disjunctionNames = new Set();
+                for (const name of alternativeNames)
+                    disjunctionNames.add(name);
+            }
             if (this.char() !== 124 /* CharacterCodes.bar */)
-                return;
+                break;
             this.scanner.pos = (this.scanner.pos + 1) | 0;
         }
+        if (isInGroup && disjunctionNames !== undefined && this.namedCapturingGroups.length > 0) {
+            const parentScope = this.namedCapturingGroups[this.namedCapturingGroups.length - 1];
+            for (const name of disjunctionNames)
+                parentScope.add(name);
+        }
     }
     // Alternative ::= Term*
     // Term ::= Assertion | Atom Quantifier?
@@ -201,7 +215,7 @@ class RegularExpressionChecker {
                                 this.scanGroupName(false);
                                 this.scanExpectedChar(62 /* CharacterCodes.greaterThan */);
                                 if (this.scanner.languageVersion() < 5 /* ScriptTarget.ES2018 */)
-                                    this.error(418 /* Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later */, groupNameStart, this.scanner.pos - groupNameStart, noArgs);
+                                    this.error(416 /* Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later */, groupNameStart, this.scanner.pos - groupNameStart, noArgs);
                                 this.numberOfCapturingGroups++;
                                 isPreviousTermQuantifiable = true;
                             }
@@ -213,8 +227,11 @@ class RegularExpressionChecker {
                                 this.scanner.pos = (this.scanner.pos + 1) | 0;
                                 this.scanPatternModifiers(setFlags);
                                 if (this.scanner.pos === flagsStart + 1)
-                                    this.error(419 /* Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign */, flagsStart, this.scanner.pos - flagsStart, noArgs);
+                                    this.error(417 /* Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign */, flagsStart, this.scanner.pos - flagsStart, noArgs);
                             }
+                            // Modifier characters make this `(?flags:` rather than a plain `(?:` group.
+                            if (this.scanner.pos !== flagsStart && this.scanner.languageVersion() < 12 /* ScriptTarget.ES2025 */)
+                                this.error(1897 /* Diagnostics.Regular_expression_pattern_modifiers_are_only_available_when_targeting_0_or_later */, flagsStart, this.scanner.pos - flagsStart, ['es2025']);
                             this.scanExpectedChar(58 /* CharacterCodes.colon */);
                             isPreviousTermQuantifiable = true;
                         }
@@ -239,10 +256,10 @@ class RegularExpressionChecker {
                         const max = this.scanDigits();
                         if (min === '') {
                             if (max !== '' || this.char() === 125 /* CharacterCodes.closeBrace */) {
-                                this.error(420 /* Diagnostics.Incomplete_quantifier_Digit_expected */, digitsStart, 0, noArgs);
+                                this.error(418 /* Diagnostics.Incomplete_quantifier_Digit_expected */, digitsStart, 0, noArgs);
                             }
                             else {
-                                this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, start, 1, [
+                                this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, start, 1, [
                                     String.fromCharCode(ch),
                                 ]);
                                 isPreviousTermQuantifiable = true;
@@ -252,12 +269,12 @@ class RegularExpressionChecker {
                         else if (max !== '' &&
                             compareDecimalStrings(min, max) > 0 &&
                             (this.anyUnicodeModeOrNonAnnexB || this.char() === 125 /* CharacterCodes.closeBrace */)) {
-                            this.error(421 /* Diagnostics.Numbers_out_of_order_in_quantifier */, digitsStart, this.scanner.pos - digitsStart, noArgs);
+                            this.error(419 /* Diagnostics.Numbers_out_of_order_in_quantifier */, digitsStart, this.scanner.pos - digitsStart, noArgs);
                         }
                     }
                     else if (min === '') {
                         if (this.anyUnicodeModeOrNonAnnexB)
-                            this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, start, 1, [
+                            this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, start, 1, [
                                 String.fromCharCode(ch),
                             ]);
                         isPreviousTermQuantifiable = true;
@@ -298,7 +315,7 @@ class RegularExpressionChecker {
                     if (ch === 41 /* CharacterCodes.closeParen */ && isInGroup)
                         return;
                     if (this.anyUnicodeModeOrNonAnnexB || ch === 41 /* CharacterCodes.closeParen */)
-                        this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                        this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
                             String.fromCharCode(ch),
                         ]);
                     this.scanner.pos = (this.scanner.pos + 1) | 0;
@@ -320,7 +337,7 @@ class RegularExpressionChecker {
         if (this.char() === 63 /* CharacterCodes.question */)
             this.scanner.pos = (this.scanner.pos + 1) | 0; // non-greedy
         if (!isPreviousTermQuantifiable)
-            this.error(422 /* Diagnostics.There_is_nothing_available_for_repetition */, start, this.scanner.pos - start, noArgs);
+            this.error(420 /* Diagnostics.There_is_nothing_available_for_repetition */, start, this.scanner.pos - start, noArgs);
         return false;
     }
     scanPatternModifiers(currentFlags) {
@@ -331,15 +348,14 @@ class RegularExpressionChecker {
             const size = charSize(ch);
             const flag = regularExpressionFlag(ch);
             if (flag === 0 /* RegularExpressionFlags.None */)
-                this.error(414 /* Diagnostics.Unknown_regular_expression_flag */, this.scanner.pos, size, noArgs);
+                this.error(412 /* Diagnostics.Unknown_regular_expression_flag */, this.scanner.pos, size, noArgs);
             else if ((currentFlags & flag) !== 0)
-                this.error(415 /* Diagnostics.Duplicate_regular_expression_flag */, this.scanner.pos, size, noArgs);
+                this.error(413 /* Diagnostics.Duplicate_regular_expression_flag */, this.scanner.pos, size, noArgs);
             else if ((flag & 28 /* RegularExpressionFlags.Modifiers */) === 0)
-                this.error(424 /* Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern */, this.scanner.pos, size, noArgs);
-            else {
+                this.error(422 /* Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern */, this.scanner.pos, size, noArgs);
+            // Modifiers need ES2025, later than any flag they can toggle, and the group reports that.
+            else
                 currentFlags |= flag;
-                this.scanner.checkRegularExpressionFlagAvailability(flag, this.scanner.pos, size);
-            }
             this.scanner.pos = (this.scanner.pos + size) | 0;
         }
         return currentFlags;
@@ -355,13 +371,13 @@ class RegularExpressionChecker {
                     this.scanExpectedChar(62 /* CharacterCodes.greaterThan */);
                 }
                 else if (this.anyUnicodeModeOrNonAnnexB || this.namedCaptureGroups) {
-                    this.error(425 /* Diagnostics.X_k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets */, this.scanner.pos - 2, 2, noArgs);
+                    this.error(423 /* Diagnostics.X_k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets */, this.scanner.pos - 2, 2, noArgs);
                 }
                 return;
             case 113 /* CharacterCodes.q */:
                 if (this.unicodeSetsMode) {
                     this.scanner.pos = (this.scanner.pos + 1) | 0;
-                    this.error(426 /* Diagnostics.X_q_is_only_available_inside_character_class */, this.scanner.pos - 2, 2, noArgs);
+                    this.error(424 /* Diagnostics.X_q_is_only_available_inside_character_class */, this.scanner.pos - 2, 2, noArgs);
                     return;
                 }
                 break;
@@ -385,7 +401,7 @@ class RegularExpressionChecker {
         let ch = this.char();
         switch (ch) {
             case -1 /* CharacterCodes.EOF */:
-                this.error(428 /* Diagnostics.Undetermined_character_escape */, this.scanner.pos - 1, 1, noArgs);
+                this.error(426 /* Diagnostics.Undetermined_character_escape */, this.scanner.pos - 1, 1, noArgs);
                 return 92 /* CharacterCodes.backslash */;
             case 99 /* CharacterCodes.c */:
                 this.scanner.pos = (this.scanner.pos + 1) | 0;
@@ -395,7 +411,7 @@ class RegularExpressionChecker {
                     return ch & 0x1f;
                 }
                 if (this.anyUnicodeModeOrNonAnnexB) {
-                    this.error(427 /* Diagnostics.X_c_must_be_followed_by_an_ASCII_letter */, this.scanner.pos - 2, 2, noArgs);
+                    this.error(425 /* Diagnostics.X_c_must_be_followed_by_an_ASCII_letter */, this.scanner.pos - 2, 2, noArgs);
                 }
                 else if (atomEscape) {
                     this.scanner.pos = (this.scanner.pos - 1) | 0;
@@ -436,10 +452,9 @@ class RegularExpressionChecker {
     scanGroupName(isReference) {
         const scanner = this.scanner;
         scanner.tokenStart = this.scanner.pos | 0;
-        scanner.scanIdentifier(0);
         const start = scanner.tokenStart;
-        if (this.scanner.pos === start) {
-            this.error(429 /* Diagnostics.Expected_a_capturing_group_name */, this.scanner.pos, 0, noArgs);
+        if (!scanner.scanIdentifier(0, 2 /* IdentifierVariant.RegExpGroupName */)) {
+            this.error(427 /* Diagnostics.Expected_a_capturing_group_name */, this.scanner.pos, 0, noArgs);
             return;
         }
         const name = scanner.getTokenValue();
@@ -447,9 +462,16 @@ class RegularExpressionChecker {
             this.groupNameReferences.push(new GroupNameReference(start, this.scanner.pos, name));
         }
         else if (this.namedCapturingGroupsContains(name)) {
-            this.error(430 /* Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other */, start, this.scanner.pos - start, noArgs);
+            this.error(428 /* Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other */, start, this.scanner.pos - start, noArgs);
         }
         else {
+            // An earlier definition is in a mutually exclusive alternative. Below ES2018 the group is
+            // reported already.
+            const languageVersion = this.scanner.languageVersion();
+            if (this.groupSpecifiers.has(name) &&
+                languageVersion >= 5 /* ScriptTarget.ES2018 */ &&
+                languageVersion < 12 /* ScriptTarget.ES2025 */)
+                this.error(1898 /* Diagnostics.Duplicate_named_capturing_groups_are_only_available_when_targeting_0_or_later */, start, this.scanner.pos - start, ['es2025']);
             if (this.namedCapturingGroups.length > 0)
                 this.namedCapturingGroups[this.namedCapturingGroups.length - 1].add(name);
             this.groupSpecifiers.add(name);
@@ -480,15 +502,15 @@ class RegularExpressionChecker {
             if (this.isClassContentExit(this.char()))
                 return false;
             if (min === -1 /* ClassValue.None */ && this.anyUnicodeModeOrNonAnnexB)
-                this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, minStart, this.scanner.pos - 1 - minStart, noArgs);
+                this.error(429 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, minStart, this.scanner.pos - 1 - minStart, noArgs);
             const maxStart = this.scanner.pos;
             const max = this.scanClassAtom();
             if (max === -1 /* ClassValue.None */ && this.anyUnicodeModeOrNonAnnexB) {
-                this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, maxStart, this.scanner.pos - maxStart, noArgs);
+                this.error(429 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, maxStart, this.scanner.pos - maxStart, noArgs);
                 continue;
             }
             if (min >= 0 && max >= 0 && min > max)
-                this.error(432 /* Diagnostics.Range_out_of_order_in_character_class */, minStart, this.scanner.pos - minStart, noArgs);
+                this.error(430 /* Diagnostics.Range_out_of_order_in_character_class */, minStart, this.scanner.pos - minStart, noArgs);
         }
         return false;
     }
@@ -513,7 +535,7 @@ class RegularExpressionChecker {
         let start = this.scanner.pos;
         let operand = -1 /* ClassValue.None */;
         if (this.isDoublePunctuatorOperator()) {
-            this.error(435 /* Diagnostics.Expected_a_class_set_operand */, this.scanner.pos, 0, noArgs);
+            this.error(433 /* Diagnostics.Expected_a_class_set_operand */, this.scanner.pos, 0, noArgs);
             this.mayContainStrings = false;
         }
         else {
@@ -523,7 +545,7 @@ class RegularExpressionChecker {
             case 45 /* CharacterCodes.minus */:
                 if (this.scanner.pos + 1 < this.end && this.charAt(this.scanner.pos + 1) === 45 /* CharacterCodes.minus */) {
                     if (isCharacterComplement && this.mayContainStrings)
-                        this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                        this.error(431 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
                     expressionMayContainStrings = this.mayContainStrings;
                     this.scanClassSetSubExpression(3 /* ClassSetExpressionType.ClassSubtraction */);
                     this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
@@ -534,18 +556,15 @@ class RegularExpressionChecker {
                 if (this.scanner.pos + 1 < this.end && this.charAt(this.scanner.pos + 1) === 38 /* CharacterCodes.ampersand */) {
                     this.scanClassSetSubExpression(2 /* ClassSetExpressionType.ClassIntersection */);
                     if (isCharacterComplement && this.mayContainStrings)
-                        this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                        this.error(431 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
                     expressionMayContainStrings = this.mayContainStrings;
                     this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
                     return this.mayContainStrings;
                 }
-                this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
-                    String.fromCharCode(ch),
-                ]);
                 break;
             default:
                 if (isCharacterComplement && this.mayContainStrings)
-                    this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                    this.error(431 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
                 expressionMayContainStrings = this.mayContainStrings;
                 break;
         }
@@ -560,56 +579,54 @@ class RegularExpressionChecker {
                 }
                 if (ch === 45 /* CharacterCodes.minus */) {
                     this.scanner.pos = (this.scanner.pos + 1) | 0;
-                    this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                    this.error(432 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
                     start = this.scanner.pos - 2;
                     operand = -2 /* ClassValue.String */;
                     continue;
                 }
                 if (operand === -1 /* ClassValue.None */)
-                    this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, start, this.scanner.pos - 1 - start, noArgs);
+                    this.error(429 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, start, this.scanner.pos - 1 - start, noArgs);
                 const secondStart = this.scanner.pos;
                 const secondOperand = this.scanClassSetOperand();
                 if (isCharacterComplement && this.mayContainStrings)
-                    this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, secondStart, this.scanner.pos - secondStart, noArgs);
+                    this.error(431 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, secondStart, this.scanner.pos - secondStart, noArgs);
                 expressionMayContainStrings = expressionMayContainStrings || this.mayContainStrings;
                 if (secondOperand === -1 /* ClassValue.None */) {
-                    this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, secondStart, this.scanner.pos - secondStart, noArgs);
+                    this.error(429 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, secondStart, this.scanner.pos - secondStart, noArgs);
                 }
                 else if (operand >= 0 && secondOperand >= 0 && operand > secondOperand) {
-                    this.error(432 /* Diagnostics.Range_out_of_order_in_character_class */, start, this.scanner.pos - start, noArgs);
+                    this.error(430 /* Diagnostics.Range_out_of_order_in_character_class */, start, this.scanner.pos - start, noArgs);
                 }
             }
-            else if (ch === 38 /* CharacterCodes.ampersand */) {
+            else if (ch === 38 /* CharacterCodes.ampersand */ &&
+                this.scanner.pos + 1 < this.end &&
+                this.charAt(this.scanner.pos + 1) === 38 /* CharacterCodes.ampersand */) {
                 start = this.scanner.pos;
-                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                this.scanner.pos = (this.scanner.pos + 2) | 0;
+                this.error(432 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
                 if (this.char() === 38 /* CharacterCodes.ampersand */) {
-                    this.scanner.pos = (this.scanner.pos + 1) | 0;
-                    this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
-                    if (this.char() === 38 /* CharacterCodes.ampersand */) {
-                        this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
-                            String.fromCharCode(ch),
-                        ]);
-                        this.scanner.pos = (this.scanner.pos + 1) | 0;
-                    }
-                }
-                else {
-                    this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos - 1, 1, [
+                    this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
                         String.fromCharCode(ch),
                     ]);
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
                 }
-                operand = this.scanner.pos - start === 1 ? 38 /* CharacterCodes.ampersand */ : -2 /* ClassValue.String */;
+                operand = -2 /* ClassValue.String */;
                 continue;
             }
             if (this.isClassContentExit(this.char()))
                 break;
             start = this.scanner.pos;
             if (this.isDoublePunctuatorOperator()) {
-                this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos, 2, noArgs);
+                this.error(432 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos, 2, noArgs);
                 this.scanner.pos = (this.scanner.pos + 2) | 0;
                 operand = -2 /* ClassValue.String */;
             }
             else {
                 operand = this.scanClassSetOperand();
+                // Each operand of a negated union must match single characters.
+                if (isCharacterComplement && this.mayContainStrings)
+                    this.error(431 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                expressionMayContainStrings = expressionMayContainStrings || this.mayContainStrings;
             }
         }
         this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
@@ -634,10 +651,10 @@ class RegularExpressionChecker {
                 if (this.char() === 45 /* CharacterCodes.minus */) {
                     this.scanner.pos = (this.scanner.pos + 1) | 0;
                     if (expressionType !== 3 /* ClassSetExpressionType.ClassSubtraction */)
-                        this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                        this.error(432 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
                 }
                 else {
-                    this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 1, 1, noArgs);
+                    this.error(432 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 1, 1, noArgs);
                 }
             }
             else if (ch === 38 /* CharacterCodes.ampersand */) {
@@ -645,16 +662,16 @@ class RegularExpressionChecker {
                 if (this.char() === 38 /* CharacterCodes.ampersand */) {
                     this.scanner.pos = (this.scanner.pos + 1) | 0;
                     if (expressionType !== 2 /* ClassSetExpressionType.ClassIntersection */)
-                        this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                        this.error(432 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
                     if (this.char() === 38 /* CharacterCodes.ampersand */) {
-                        this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                        this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
                             String.fromCharCode(ch),
                         ]);
                         this.scanner.pos = (this.scanner.pos + 1) | 0;
                     }
                 }
                 else {
-                    this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos - 1, 1, [
+                    this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos - 1, 1, [
                         String.fromCharCode(ch),
                     ]);
                 }
@@ -667,7 +684,7 @@ class RegularExpressionChecker {
             }
             ch = this.char();
             if (this.isClassContentExit(ch)) {
-                this.error(435 /* Diagnostics.Expected_a_class_set_operand */, this.scanner.pos, 0, noArgs);
+                this.error(433 /* Diagnostics.Expected_a_class_set_operand */, this.scanner.pos, 0, noArgs);
                 break;
             }
             this.scanClassSetOperand();
@@ -698,7 +715,7 @@ class RegularExpressionChecker {
                     this.scanExpectedChar(125 /* CharacterCodes.closeBrace */);
                     return -1 /* ClassValue.None */;
                 }
-                this.error(436 /* Diagnostics.X_q_must_be_followed_by_string_alternatives_enclosed_in_braces */, this.scanner.pos - 2, 2, noArgs);
+                this.error(434 /* Diagnostics.X_q_must_be_followed_by_string_alternatives_enclosed_in_braces */, this.scanner.pos - 2, 2, noArgs);
                 return 113 /* CharacterCodes.q */;
             }
             this.scanner.pos = (this.scanner.pos - 1) | 0;
@@ -778,7 +795,7 @@ class RegularExpressionChecker {
                 case 64 /* CharacterCodes.at */:
                 case 96 /* CharacterCodes.backtick */:
                 case 126 /* CharacterCodes.tilde */:
-                    this.error(437 /* Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 2, noArgs);
+                    this.error(435 /* Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 2, noArgs);
                     this.scanner.pos = (this.scanner.pos + 2) | 0;
                     return -2 /* ClassValue.String */;
             }
@@ -793,7 +810,7 @@ class RegularExpressionChecker {
             case 125 /* CharacterCodes.closeBrace */:
             case 45 /* CharacterCodes.minus */:
             case 124 /* CharacterCodes.bar */:
-                this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                this.error(421 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
                     String.fromCharCode(ch),
                 ]);
                 this.scanner.pos = (this.scanner.pos + 1) | 0;
@@ -847,7 +864,7 @@ class RegularExpressionChecker {
                 this.scanner.pos = (this.scanner.pos - 1) | 0;
                 return false;
             }
-            this.error(446 /* Diagnostics.X_0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces */, this.scanner.pos - 2, 2, [String.fromCharCode(ch)]);
+            this.error(444 /* Diagnostics.X_0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces */, this.scanner.pos - 2, 2, [String.fromCharCode(ch)]);
             return true;
         }
         this.scanner.pos = (this.scanner.pos + 1) | 0;
@@ -856,10 +873,10 @@ class RegularExpressionChecker {
         if (this.char() === 61 /* CharacterCodes.equals */) {
             const propertyName = nonBinaryUnicodeProperties.get(nameOrValue) ?? '';
             if (this.scanner.pos === nameOrValueStart) {
-                this.error(438 /* Diagnostics.Expected_a_Unicode_property_name */, this.scanner.pos, 0, noArgs);
+                this.error(436 /* Diagnostics.Expected_a_Unicode_property_name */, this.scanner.pos, 0, noArgs);
             }
             else if (propertyName === '') {
-                this.error(439 /* Diagnostics.Unknown_Unicode_property_name */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+                this.error(437 /* Diagnostics.Unknown_Unicode_property_name */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
                 const suggestion = getSpellingSuggestion(nameOrValue, mapKeys(nonBinaryUnicodeProperties));
                 if (suggestion !== '')
                     this.error(303 /* Diagnostics.Did_you_mean_0 */, nameOrValueStart, this.scanner.pos - nameOrValueStart, [suggestion]);
@@ -868,12 +885,12 @@ class RegularExpressionChecker {
             const valueStart = this.scanner.pos;
             const value = this.scanWordCharacters();
             if (this.scanner.pos === valueStart) {
-                this.error(440 /* Diagnostics.Expected_a_Unicode_property_value */, this.scanner.pos, 0, noArgs);
+                this.error(438 /* Diagnostics.Expected_a_Unicode_property_value */, this.scanner.pos, 0, noArgs);
             }
             else if (propertyName !== '') {
                 const values = valuesOfNonBinaryUnicodeProperty(propertyName);
                 if (!values.has(value)) {
-                    this.error(441 /* Diagnostics.Unknown_Unicode_property_value */, valueStart, this.scanner.pos - valueStart, noArgs);
+                    this.error(439 /* Diagnostics.Unknown_Unicode_property_value */, valueStart, this.scanner.pos - valueStart, noArgs);
                     const suggestion = getSpellingSuggestion(value, setToArray(values));
                     if (suggestion !== '')
                         this.error(303 /* Diagnostics.Did_you_mean_0 */, valueStart, this.scanner.pos - valueStart, [suggestion]);
@@ -881,18 +898,18 @@ class RegularExpressionChecker {
             }
         }
         else if (this.scanner.pos === nameOrValueStart) {
-            this.error(442 /* Diagnostics.Expected_a_Unicode_property_name_or_value */, this.scanner.pos, 0, noArgs);
+            this.error(440 /* Diagnostics.Expected_a_Unicode_property_name_or_value */, this.scanner.pos, 0, noArgs);
         }
         else if (binaryUnicodePropertiesOfStrings.has(nameOrValue)) {
             if (!this.unicodeSetsMode)
-                this.error(443 /* Diagnostics.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+                this.error(441 /* Diagnostics.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
             else if (isCharacterComplement)
-                this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+                this.error(431 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
             else
                 this.mayContainStrings = true;
         }
         else if (!generalCategoryValues.has(nameOrValue) && !binaryUnicodeProperties.has(nameOrValue)) {
-            this.error(444 /* Diagnostics.Unknown_Unicode_property_name_or_value */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+            this.error(442 /* Diagnostics.Unknown_Unicode_property_name_or_value */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
             const candidates = setToArray(generalCategoryValues);
             for (const name of binaryUnicodeProperties)
                 candidates.push(name);
@@ -904,7 +921,7 @@ class RegularExpressionChecker {
         }
         this.scanExpectedChar(125 /* CharacterCodes.closeBrace */);
         if (!this.anyUnicodeMode)
-            this.error(445 /* Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set */, start, this.scanner.pos - start, noArgs);
+            this.error(443 /* Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set */, start, this.scanner.pos - start, noArgs);
         return true;
     }
     scanWordCharacters() {

package/dist/api/compiler/relations.d.ts

@@ -14,9 +14,8 @@ export declare const enum RelationComparisonResult {
     ReportsUnmeasurable = 8,
     ReportsUnreliable = 16,
     ComplexityOverflow = 32,
-    StackDepthOverflow = 64,
     ReportsMask = 24,
-    Overflow = 96
+    Overflow = 32
 }
 /**
  * Cached results of one relation by numeric relation key (see getRelationKey): an open-addressing
@@ -30,7 +29,10 @@ export declare class Relation {
     private results;
     private count;
     get(key: number): number;
-    set(key: number, result: number): void;
+    /** Sets the result of `key`, and returns whether the key is new. */
+    set(key: number, result: number): boolean;
+    /** Removes `key`, moving later entries of its probe run back so lookups still find them. */
+    delete(key: number): void;
     size(): number;
     private grow;
 }
@@ -138,6 +140,8 @@ export declare class Relater extends TypeComparer {
     expandingFlags: ExpandingFlags;
     overflow: boolean;
     relationCount: number;
+    /** The keys this check added to the relation, while relating without reporting first. */
+    addedKeys: number[] | undefined;
     /** The intersection state passed to `compare` during signature comparisons. */
     signatureIntersectionState: IntersectionState;
     varianceSetsCheckFailed: boolean;
@@ -165,6 +169,7 @@ export declare class Relater extends TypeComparer {
      * comparing the pair, assumes related for deeply nested expansions, and overflows at depth 100.
      */
     recursiveTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState, recursionFlags: RecursionFlags): Ternary;
+    record(key: number, result: number): void;
     resetMaybeStack(maybeStart: number, propagatingVarianceFlags: number, markAllAsSucceeded: boolean): void;
     structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary;
     /**
@@ -236,11 +241,29 @@ export declare function setStackEntry(stack: Type[], depth: number, t: Type): vo
  * last.
  */
 export declare function isDeeplyNestedType(c: Checker, t: Type, stack: readonly Type[], depth: number, maxDepth: number): boolean;
+/**
+ * isDeeplyNestedType for the newest entry of `stack[start..end)`, counting only the entries in that range.
+ * `identities` holds the recursion identity of each entry of the range once a check has computed it: 0 before
+ * that, and -1 for an entry whose recursion identity target is an intersection, which is matched by its
+ * constituents each time. Later checks compare the kept identities. The identities are computed when and in the
+ * order isDeeplyNestedType computes them, so the types and symbol ids they create come in the same order.
+ */
+export declare function isDeeplyNestedStackEntry(c: Checker, stack: readonly Type[], identities: RecursionId[], start: number, end: number, maxDepth: number): boolean;
 /** An identity shared by instantiations of a type, so infinitely expanding instantiations can be detected. */
-export declare function getRecursionIdentity(t: Type): RecursionId;
+export declare function getRecursionIdentity(c: Checker, t: Type): RecursionId;
 export declare function isMarkerType(c: Checker, t: Type): boolean;
 export declare function getVariances(c: Checker, t: Type): VarianceFlags[];
 export declare function getAliasVariances(c: Checker, symbol: Symbol): VarianceFlags[];
+/**
+ * The measured variance of each type parameter, from relating marker instantiations; empty when
+ * requested recursively.
+ */
+/** A generic type whose variances are being computed. */
+export declare class VarianceStackEntry {
+    readonly symbol: Symbol;
+    readonly typeParameters: readonly Type[];
+    constructor(symbol: Symbol, typeParameters: readonly Type[]);
+}
 export declare function createMarkerType(c: Checker, symbol: Symbol, source: Type, target: Type): Type;
 export declare function getTypeParameterModifiers(tp: Type): ModifierFlags;
 export declare function isEmptyArrayLiteralType(c: Checker, t: Type): boolean;