@@ -728,7 +728,7 @@ namespace ts {
728
728
const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
729
729
const numberOrBigIntType = getUnionType([numberType, bigintType]);
730
730
731
- const identityMapper: TypeMapper = makeFunctionTypeMapper(t => t );
731
+ const identityMapper: TypeMapper = makeUnaryTypeMapper(anyType, anyType );
732
732
const restrictiveMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? getRestrictiveTypeParameter(<TypeParameter>t) : t);
733
733
const permissiveMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? wildcardType : t);
734
734
@@ -13542,16 +13542,16 @@ namespace ts {
13542
13542
}
13543
13543
13544
13544
function createTypeMapper(sources: readonly TypeParameter[], targets: readonly Type[] | undefined): TypeMapper {
13545
- return sources.length === 1 ?
13546
- makeUnaryTypeMapper (sources[0], targets ? targets[0] : anyType) :
13547
- makeMultipleTypeMapper (sources, targets);
13545
+ return sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) :
13546
+ sources.length === 2 ? makeSimpleTypeMapper (sources[0], targets ? targets[0] : anyType, sources[1], targets ? targets[1 ] : anyType) :
13547
+ makeArrayTypeMapper (sources, targets);
13548
13548
}
13549
13549
13550
13550
function getMappedType(type: Type, map: TypeMapper): Type {
13551
13551
switch (map.kind) {
13552
- case TypeMapKind.Single :
13553
- return type === map.source ? map.target : type;
13554
- case TypeMapKind.Multiple :
13552
+ case TypeMapKind.Simple :
13553
+ return type === map.source1 ? map.target1 : type === map.source2 ? map.target2 : type;
13554
+ case TypeMapKind.Array :
13555
13555
const sources = map.sources;
13556
13556
const targets = map.targets;
13557
13557
for (let i = 0; i < sources.length; i++) {
@@ -13562,21 +13562,31 @@ namespace ts {
13562
13562
return type;
13563
13563
case TypeMapKind.Function:
13564
13564
return map.func(type);
13565
+ case TypeMapKind.Composite:
13566
+ return instantiateType(getMappedType(type, map.mapper1), map.mapper2);
13565
13567
}
13566
13568
}
13567
13569
13568
13570
function makeUnaryTypeMapper(source: Type, target: Type): TypeMapper {
13569
- return { kind: TypeMapKind.Single, source, target } ;
13571
+ return makeSimpleTypeMapper( source, target, anyType, anyType) ;
13570
13572
}
13571
13573
13572
- function makeMultipleTypeMapper(sources: readonly TypeParameter[], targets: readonly Type[] | undefined): TypeMapper {
13573
- return { kind: TypeMapKind.Multiple, sources, targets };
13574
+ function makeSimpleTypeMapper(source1: Type, target1: Type, source2: Type, target2: Type): TypeMapper {
13575
+ return { kind: TypeMapKind.Simple, source1, target1, source2, target2 };
13576
+ }
13577
+
13578
+ function makeArrayTypeMapper(sources: readonly TypeParameter[], targets: readonly Type[] | undefined): TypeMapper {
13579
+ return { kind: TypeMapKind.Array, sources, targets };
13574
13580
}
13575
13581
13576
13582
function makeFunctionTypeMapper(func: (t: Type) => Type): TypeMapper {
13577
13583
return { kind: TypeMapKind.Function, func };
13578
13584
}
13579
13585
13586
+ function makeCompositeTypeMapper(mapper1: TypeMapper, mapper2: TypeMapper): TypeMapper {
13587
+ return { kind: TypeMapKind.Composite, mapper1, mapper2 };
13588
+ }
13589
+
13580
13590
function createTypeEraser(sources: readonly TypeParameter[]): TypeMapper {
13581
13591
return createTypeMapper(sources, /*targets*/ undefined);
13582
13592
}
@@ -13589,26 +13599,20 @@ namespace ts {
13589
13599
return makeFunctionTypeMapper(t => findIndex(context.inferences, info => info.typeParameter === t) >= index ? unknownType : t);
13590
13600
}
13591
13601
13592
- function getTypeMapperSources(mapper: TypeMapper) {
13593
- return mapper.kind === TypeMapKind.Single ? [mapper.source] : mapper.kind === TypeMapKind.Multiple ? mapper.sources : emptyArray;
13594
- }
13595
-
13596
- function getTypeMapperTargets(mapper: TypeMapper) {
13597
- return mapper.kind === TypeMapKind.Single ? [mapper.target] : mapper.kind === TypeMapKind.Multiple ? mapper.targets : emptyArray;
13598
- }
13599
-
13600
13602
function combineTypeMappers(mapper1: TypeMapper | undefined, mapper2: TypeMapper): TypeMapper;
13601
13603
function combineTypeMappers(mapper1: TypeMapper, mapper2: TypeMapper | undefined): TypeMapper;
13602
13604
function combineTypeMappers(mapper1: TypeMapper, mapper2: TypeMapper): TypeMapper {
13603
- if (!mapper1) return mapper2;
13604
- if (!mapper2) return mapper1;
13605
- return mapper1.kind !== TypeMapKind.Function && mapper2.kind !== TypeMapKind.Function ?
13606
- createTypeMapper(concatenate(getTypeMapperSources(mapper1), getTypeMapperSources(mapper2)),
13607
- concatenate(map(getTypeMapperTargets(mapper1), t => instantiateType(t, mapper2)), getTypeMapperTargets(mapper2))) :
13608
- makeFunctionTypeMapper(t => instantiateType(getMappedType(t, mapper1), mapper2));
13605
+ return !mapper1 ? mapper2 : !mapper2 ? mapper1 : makeCompositeTypeMapper(mapper1, mapper2);
13609
13606
}
13610
13607
13611
13608
function createReplacementMapper(source: Type, target: Type, baseMapper: TypeMapper): TypeMapper {
13609
+ switch (baseMapper.kind) {
13610
+ case TypeMapKind.Simple:
13611
+ return makeSimpleTypeMapper(baseMapper.source1, baseMapper.source1 === source ? target : baseMapper.target1,
13612
+ baseMapper.source2, baseMapper.source2 === source ? target : baseMapper.target2);
13613
+ case TypeMapKind.Array:
13614
+ return makeArrayTypeMapper(baseMapper.sources, map(baseMapper.targets, (t, i) => baseMapper.sources[i] === source ? target : t));
13615
+ }
13612
13616
return makeFunctionTypeMapper(t => t === source ? target : getMappedType(t, baseMapper));
13613
13617
}
13614
13618
0 commit comments