fix(checker): narrow Uppercase/Lowercase/Capitalize/Uncapitalize<string> via equality checks

[erantianantha]

Fixes #63724.

Problem

Uppercase<string> (and its siblings Lowercase, Capitalize, Uncapitalize) could not be narrowed by equality checks against specific string literals:

const prefix = "be".toUpperCase() as Uppercase<string>;
if (prefix === "BE" || prefix === "LU" || prefix === "NL") {
    countryCode = prefix; // ❌ Type 'Uppercase<string>' is not assignable to '"BE" | "LU" | "NL"'
}

Additionally, always-false comparisons were not flagged:

function fn(foo: Uppercase<string>) {
    if (foo === "ba") {} // ❌ No error, but "ba" can never be Uppercase<string>
}

Root Cause

Bug 1 — replacePrimitivesWithLiterals in flow.go: The narrowing pipeline calls filterType (correctly retaining Uppercase<string> as comparable to "BE"), then calls replacePrimitivesWithLiterals to substitute the mapping with the literal. That function guards on TypeFlagsString | TypeFlagsTemplateLiteral but not TypeFlagsStringMapping, so Uppercase<string> fell through the switch and was returned unchanged.

Bug 2 — Comparable relation in relater.go: When checking isTypeComparableTo(Uppercase<string>, "ba"), the code hit the source=StringMapping, target≠StringMapping branch, which fell through to the base-constraint (string). Since "ba" is assignable to string, the comparison was deemed comparable in both directions, suppressing the TS2367 diagnostic.

Fix

tsc/internal/checker/flow.go — replacePrimitivesWithLiterals:

• Added TypeFlagsStringMapping to the outer guard.
• Added a case t.flags&TypeFlagsStringMapping != 0 branch that uses isMemberOfStringMapping to filter the right-hand side: only string literals whose mapped form equals themselves are kept (e.g. Uppercase("BE") = "BE" ✓, Uppercase("be") = "BE" ≠ "be" ✗).

tsc/internal/checker/relater.go — structured-type comparable relation:

• In the source=StringMapping, target=StringLiteral path within the comparable relation specifically, delegated to isMemberOfStringMapping instead of the base-constraint fallthrough.

Result

const prefix: Uppercase<string> = ...;
if (prefix === "BE" || prefix === "LU" || prefix === "NL") {
    countryCode = prefix; // ✅ narrowed to "BE" | "LU" | "NL"
}

function fn(foo: Uppercase<string>) {
    if (foo === "ba") {} // ✅ TS2367: types 'Uppercase<string>' and '"ba"' have no overlap
    if (foo === "BA") {} // ✅ no error
}

All four string-mapping intrinsics (Uppercase, Lowercase, Capitalize, Uncapitalize) benefit from the same fix.

[Copilot]

🟡 Changes recommended

Generic mappings and mixed-union comparisons can be incorrectly rejected or narrowed.

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Pull request overview

Fixes string-mapping equality narrowing and impossible-comparison diagnostics.

Changes:

• Extends narrowing for intrinsic string mappings.
• Tightens literal comparability.
• Adds conformance coverage and baselines.

File summaries

File	Description
tsc/internal/checker/flow.go	Narrows string mappings to literals.
tsc/internal/checker/relater.go	Checks mapping/literal comparability.
tsc/testdata/tests/cases/conformance/types/literal/stringMappingNarrowing.ts	Adds conformance cases.
tsc/testdata/baselines/reference/conformance/stringMappingNarrowing.types	Records inferred types.
tsc/testdata/baselines/reference/conformance/stringMappingNarrowing.symbols	Records symbols.
tsc/testdata/baselines/reference/conformance/stringMappingNarrowing.js	Records emitted output.
tsc/testdata/baselines/reference/conformance/stringMappingNarrowing.errors.txt	Records expected diagnostics.

Review details

Suppressed comments (1)

tsc/internal/checker/flow.go:1925

• This predicate does not compute overlap per union constituent. It drops valid literals for generic mappings (for example "A" versus Uppercase<T>), while the unconditional fallback retains every template/string-mapping constituent, so narrowing x: Uppercase<string> against Uppercase<string> | Lowercase<string> can actually broaden x. Filter every candidate with the comparable relation instead; that preserves only constituents that can overlap with this mapping.

				return c.filterType(typeWithLiterals, func(lit *Type) bool {
					if lit.flags&TypeFlagsStringLiteral != 0 {
						return c.isMemberOfStringMapping(lit, t)
					}

• Files reviewed: 7/7 changed files
• Comments generated: 3
• Review effort level: Balanced