Add trie-based fast path for template literal union assignability

When checking if a string literal is assignable to a union containing
5+ template literal types, use a lazily-built prefix trie cached on the
UnionType to find matching templates in O(L) instead of O(n) linear
scan. This avoids calling isTypeMatchedByTemplateLiteralType against
every union member.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: eps1lon

internal/checker/relater.go

@@ -1152,6 +1152,29 @@ func (c *Checker) findMatchingTemplateLiteralInTrie(trie *templateLiteralTrieNod
 	return nil
 }
 
+func (c *Checker) buildTemplateLiteralTrie(unionType *Type) *templateLiteralTrieNode {
+	types := unionType.Types()
+	var templateTypes []*Type
+	for _, t := range types {
+		if t.flags&TypeFlagsTemplateLiteral != 0 {
+			templateTypes = append(templateTypes, t)
+		}
+	}
+	if len(templateTypes) < 5 {
+		return nil
+	}
+	return c.buildTemplateLiteralTrieFromTypes(templateTypes)
+}
+
+func (c *Checker) getTemplateLiteralTrie(unionType *Type) *templateLiteralTrieNode {
+	u := unionType.AsUnionType()
+	if !u.templateLiteralTrieComputed {
+		u.templateLiteralTrie = c.buildTemplateLiteralTrie(unionType)
+		u.templateLiteralTrieComputed = true
+	}
+	return u.templateLiteralTrie
+}
+
 // Return the name of a discriminant property for which it was possible and feasible to construct a map of
 // constituent types keyed by the literal types of the property by that name in each constituent type. Return
 // an empty string if no such discriminant property exists.
@@ -3013,6 +3036,36 @@ func (r *Relater) typeRelatedToSomeType(source *Type, target *Type, reportErrors
 			}
 		}
 	}
+	// Fast path: trie-based lookup for string literal source against unions with template literals
+	if source.flags&TypeFlagsStringLiteral != 0 {
+		trie := r.c.getTemplateLiteralTrie(target)
+		if trie != nil {
+			trieMatch := r.c.findMatchingTemplateLiteralInTrie(trie, source, r.isRelatedToWorker)
+			if trieMatch != nil {
+				related := r.isRelatedToEx(source, trieMatch, RecursionFlagsTarget, false /*reportErrors*/, nil /*headMessage*/, intersectionState)
+				if related != TernaryFalse {
+					return related
+				}
+			}
+			// Trie covered all template literals; containsType covered all string literals.
+			// Check remaining non-literal, non-template members.
+			for _, t := range targetTypes {
+				if t.flags&(TypeFlagsStringLiteral|TypeFlagsTemplateLiteral) == 0 {
+					related := r.isRelatedToEx(source, t, RecursionFlagsTarget, false /*reportErrors*/, nil /*headMessage*/, intersectionState)
+					if related != TernaryFalse {
+						return related
+					}
+				}
+			}
+			if reportErrors {
+				bestMatchingType := r.c.getBestMatchingType(source, target, r.isRelatedToSimple)
+				if bestMatchingType != nil {
+					r.isRelatedToEx(source, bestMatchingType, RecursionFlagsTarget, true /*reportErrors*/, nil /*headMessage*/, intersectionState)
+				}
+			}
+			return TernaryFalse
+		}
+	}
 	for _, t := range targetTypes {
 		related := r.isRelatedToEx(source, t, RecursionFlagsTarget, false /*reportErrors*/, nil /*headMessage*/, intersectionState)
 		if related != TernaryFalse {

internal/checker/types.go

@@ -989,11 +989,13 @@ func (t *UnionOrIntersectionType) Types() []*Type {
 
 type UnionType struct {
 	UnionOrIntersectionType
-	resolvedReducedType *Type
-	regularType         *Type
-	origin              *Type           // Denormalized union, intersection, or index type in which union originates
-	keyPropertyName     string          // Property with unique unit type that exists in every object/intersection in union type
-	constituentMap      map[*Type]*Type // Constituents keyed by unit type discriminants
+	resolvedReducedType         *Type
+	regularType                 *Type
+	origin                      *Type           // Denormalized union, intersection, or index type in which union originates
+	keyPropertyName             string          // Property with unique unit type that exists in every object/intersection in union type
+	constituentMap              map[*Type]*Type // Constituents keyed by unit type discriminants
+	templateLiteralTrie         *templateLiteralTrieNode
+	templateLiteralTrieComputed bool
 }
 
 // IntersectionType