Skip to content

Commit 5094f76

Browse files
ahejlsbergahejlsberg
committed
Remove 'T extends U' type constructor
1 parent 53b1572 commit 5094f76

10 files changed

Lines changed: 8 additions & 146 deletions

File tree

‎src/compiler/binder.ts‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3428,7 +3428,6 @@ namespace ts {
34283428
case SyntaxKind.TypeAliasDeclaration:
34293429
case SyntaxKind.ThisType:
34303430
case SyntaxKind.TypeOperator:
3431-
case SyntaxKind.BinaryType:
34323431
case SyntaxKind.IndexedAccessType:
34333432
case SyntaxKind.MappedType:
34343433
case SyntaxKind.LiteralType:

‎src/compiler/checker.ts‎

Lines changed: 0 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -281,7 +281,6 @@ namespace ts {
281281
const literalTypes = createMap<LiteralType>();
282282
const indexedAccessTypes = createMap<IndexedAccessType>();
283283
const conditionalTypes = createMap<ConditionalType>();
284-
const extendsTypes = createMap<ExtendsType>();
285284
const evolvingArrayTypes: EvolvingArrayType[] = [];
286285
const undefinedProperties = createMap<Symbol>() as UnderscoreEscapedMap<Symbol>;
287286

@@ -2649,11 +2648,6 @@ namespace ts {
26492648
const falseTypeNode = typeToTypeNodeHelper((<ConditionalType>type).falseType, context);
26502649
return createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
26512650
}
2652-
if (type.flags & TypeFlags.Extends) {
2653-
const leftTypeNode = typeToTypeNodeHelper((<ExtendsType>type).checkType, context);
2654-
const rightTypeNode = typeToTypeNodeHelper((<ExtendsType>type).extendsType, context);
2655-
return createBinaryTypeNode(leftTypeNode, SyntaxKind.ExtendsKeyword, rightTypeNode);
2656-
}
26572651

26582652
Debug.fail("Should be unreachable.");
26592653

@@ -3437,13 +3431,6 @@ namespace ts {
34373431
writeSpace(writer);
34383432
writeType((<ConditionalType>type).falseType, TypeFormatFlags.InElementType);
34393433
}
3440-
else if (type.flags & TypeFlags.Extends) {
3441-
writeType((<ExtendsType>type).checkType, TypeFormatFlags.InElementType);
3442-
writeSpace(writer);
3443-
writer.writeKeyword("extends");
3444-
writeSpace(writer);
3445-
writeType((<ExtendsType>type).extendsType, TypeFormatFlags.InElementType);
3446-
}
34473434
else {
34483435
// Should never get here
34493436
// { ... }
@@ -6425,9 +6412,6 @@ namespace ts {
64256412
else if (type.flags & TypeFlags.Index) {
64266413
return stringType;
64276414
}
6428-
else if (type.flags & TypeFlags.Extends) {
6429-
return booleanType;
6430-
}
64316415
return undefined;
64326416
}
64336417

@@ -6496,9 +6480,6 @@ namespace ts {
64966480
if (t.flags & TypeFlags.Conditional) {
64976481
return getBaseConstraint(getConstraintOfConditionalType(<ConditionalType>t));
64986482
}
6499-
if (t.flags & TypeFlags.Extends) {
6500-
return booleanType;
6501-
}
65026483
if (isGenericMappedType(t)) {
65036484
return emptyObjectType;
65046485
}
@@ -8435,47 +8416,6 @@ namespace ts {
84358416
return links.resolvedType;
84368417
}
84378418

8438-
function createExtendsType(checkType: Type, extendsType: Type) {
8439-
const type = <ExtendsType>createType(TypeFlags.Extends);
8440-
type.checkType = checkType;
8441-
type.extendsType = extendsType;
8442-
return type;
8443-
}
8444-
8445-
function getExtendsType(checkType: Type, extendsType: Type): Type {
8446-
// sys.write(`getExtendsType(${typeToString(checkType)}, ${typeToString(extendsType)})\n`);
8447-
if (checkType.flags & TypeFlags.Union) {
8448-
return getUnionType(map((<UnionType>checkType).types, t => getExtendsType(t, extendsType)));
8449-
}
8450-
if (checkType.flags & TypeFlags.Any) {
8451-
return booleanType;
8452-
}
8453-
// Return trueType if type is definitely assignable
8454-
if (isTypeAssignableTo(checkType, extendsType)) {
8455-
return trueType;
8456-
}
8457-
// Return falseType is type is definitely not assignable
8458-
if (!isTypeAssignableTo(instantiateType(checkType, anyMapper), instantiateType(extendsType, constraintMapper))) {
8459-
// Type is definitely not assignable
8460-
return falseType;
8461-
}
8462-
// Type is possibly assignable, defer the check
8463-
const id = checkType.id + "," + extendsType.id;
8464-
let type = extendsTypes.get(id);
8465-
if (!type) {
8466-
extendsTypes.set(id, type = createExtendsType(checkType, extendsType));
8467-
}
8468-
return type;
8469-
}
8470-
8471-
function getTypeFromBinaryTypeNode(node: BinaryTypeNode): Type {
8472-
const links = getNodeLinks(node);
8473-
if (!links.resolvedType) {
8474-
links.resolvedType = getExtendsType(getTypeFromTypeNode(node.left), getTypeFromTypeNode(node.right));
8475-
}
8476-
return links.resolvedType;
8477-
}
8478-
84798419
function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node: TypeNode): Type {
84808420
const links = getNodeLinks(node);
84818421
if (!links.resolvedType) {
@@ -8766,8 +8706,6 @@ namespace ts {
87668706
return getTypeFromMappedTypeNode(<MappedTypeNode>node);
87678707
case SyntaxKind.ConditionalType:
87688708
return getTypeFromConditionalTypeNode(<ConditionalTypeNode>node);
8769-
case SyntaxKind.BinaryType:
8770-
return getTypeFromBinaryTypeNode(<BinaryTypeNode>node);
87718709
// This function assumes that an identifier or qualified name is a type expression
87728710
// Callers should first ensure this by calling isTypeNode
87738711
case SyntaxKind.Identifier:
@@ -9096,9 +9034,6 @@ namespace ts {
90969034
if (type.flags & TypeFlags.Conditional) {
90979035
return getConditionalTypeInstantiation(<ConditionalType>type, mapper);
90989036
}
9099-
if (type.flags & TypeFlags.Extends) {
9100-
return getExtendsType(instantiateType((<ExtendsType>type).checkType, mapper), instantiateType((<ExtendsType>type).extendsType, mapper));
9101-
}
91029037
}
91039038
return type;
91049039
}
@@ -11652,10 +11587,6 @@ namespace ts {
1165211587
inferFromTypes((<ConditionalType>source).trueType, (<ConditionalType>target).trueType);
1165311588
inferFromTypes((<ConditionalType>source).falseType, (<ConditionalType>target).falseType);
1165411589
}
11655-
else if (source.flags & TypeFlags.Extends && target.flags & TypeFlags.Extends) {
11656-
inferFromTypes((<ExtendsType>source).checkType, (<ExtendsType>target).checkType);
11657-
inferFromTypes((<ExtendsType>source).extendsType, (<ExtendsType>target).extendsType);
11658-
}
1165911590
else if (target.flags & TypeFlags.UnionOrIntersection) {
1166011591
const targetTypes = (<UnionOrIntersectionType>target).types;
1166111592
let typeVariableCount = 0;
@@ -24015,9 +23946,6 @@ namespace ts {
2401523946
return checkTypeOperator(<TypeOperatorNode>node);
2401623947
case SyntaxKind.ConditionalType:
2401723948
return checkConditionalType(<ConditionalTypeNode>node);
24018-
case SyntaxKind.BinaryType:
24019-
forEachChild(node, checkSourceElement);
24020-
return;
2402123949
case SyntaxKind.JSDocAugmentsTag:
2402223950
return checkJSDocAugmentsTag(node as JSDocAugmentsTag);
2402323951
case SyntaxKind.JSDocTypedefTag:

‎src/compiler/declarationEmitter.ts‎

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -456,8 +456,6 @@ namespace ts {
456456
return emitParenType(<ParenthesizedTypeNode>type);
457457
case SyntaxKind.TypeOperator:
458458
return emitTypeOperator(<TypeOperatorNode>type);
459-
case SyntaxKind.BinaryType:
460-
return emitBinaryType(<BinaryTypeNode>type);
461459
case SyntaxKind.IndexedAccessType:
462460
return emitIndexedAccessType(<IndexedAccessTypeNode>type);
463461
case SyntaxKind.MappedType:
@@ -571,12 +569,6 @@ namespace ts {
571569
emitType(type.type);
572570
}
573571

574-
function emitBinaryType(node: BinaryTypeNode) {
575-
emitType(node.left);
576-
write(" extends ");
577-
emitType(node.right);
578-
}
579-
580572
function emitIndexedAccessType(node: IndexedAccessTypeNode) {
581573
emitType(node.objectType);
582574
write("[");

‎src/compiler/emitter.ts‎

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -572,8 +572,6 @@ namespace ts {
572572
return emitThisType();
573573
case SyntaxKind.TypeOperator:
574574
return emitTypeOperator(<TypeOperatorNode>node);
575-
case SyntaxKind.BinaryType:
576-
return emitBinaryType(<BinaryTypeNode>node);
577575
case SyntaxKind.IndexedAccessType:
578576
return emitIndexedAccessType(<IndexedAccessTypeNode>node);
579577
case SyntaxKind.MappedType:
@@ -1159,12 +1157,6 @@ namespace ts {
11591157
emit(node.type);
11601158
}
11611159

1162-
function emitBinaryType(node: BinaryTypeNode) {
1163-
emit(node.left);
1164-
write(" extends ");
1165-
emit(node.right);
1166-
}
1167-
11681160
function emitIndexedAccessType(node: IndexedAccessTypeNode) {
11691161
emit(node.objectType);
11701162
write("[");

‎src/compiler/factory.ts‎

Lines changed: 1 addition & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -767,22 +767,6 @@ namespace ts {
767767
return node.type !== type ? updateNode(createTypeOperatorNode(node.operator, type), node) : node;
768768
}
769769

770-
export function createBinaryTypeNode(left: TypeNode, operator: SyntaxKind.ExtendsKeyword, right: TypeNode) {
771-
const node = createSynthesizedNode(SyntaxKind.BinaryType) as BinaryTypeNode;
772-
node.left = parenthesizeBinaryTypeMember(left);
773-
node.operator = operator;
774-
node.right = parenthesizeBinaryTypeMember(right);
775-
return node;
776-
}
777-
778-
export function updateBinaryTypeNode(node: BinaryTypeNode, left: TypeNode, operator: SyntaxKind.ExtendsKeyword, right: TypeNode) {
779-
return node.left !== left
780-
|| node.operator !== operator
781-
|| node.right !== right
782-
? updateNode(createBinaryTypeNode(left, operator, right), node)
783-
: node;
784-
}
785-
786770
export function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode) {
787771
const node = createSynthesizedNode(SyntaxKind.IndexedAccessType) as IndexedAccessTypeNode;
788772
node.objectType = parenthesizeElementTypeMember(objectType);
@@ -4119,10 +4103,6 @@ namespace ts {
41194103
return member.kind === SyntaxKind.ConditionalType ? createParenthesizedType(member) : member;
41204104
}
41214105

4122-
export function parenthesizeBinaryTypeMember(member: TypeNode) {
4123-
return member.kind === SyntaxKind.BinaryType ? createParenthesizedType(member) : parenthesizeConditionalTypeMember(member);
4124-
}
4125-
41264106
export function parenthesizeElementTypeMember(member: TypeNode) {
41274107
switch (member.kind) {
41284108
case SyntaxKind.UnionType:
@@ -4131,7 +4111,7 @@ namespace ts {
41314111
case SyntaxKind.ConstructorType:
41324112
return createParenthesizedType(member);
41334113
}
4134-
return parenthesizeBinaryTypeMember(member);
4114+
return parenthesizeConditionalTypeMember(member);
41354115
}
41364116

41374117
export function parenthesizeArrayTypeMember(member: TypeNode) {

‎src/compiler/parser.ts‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -183,9 +183,6 @@ namespace ts {
183183
case SyntaxKind.ParenthesizedType:
184184
case SyntaxKind.TypeOperator:
185185
return visitNode(cbNode, (<ParenthesizedTypeNode | TypeOperatorNode>node).type);
186-
case SyntaxKind.BinaryType:
187-
return visitNode(cbNode, (<BinaryTypeNode>node).left) ||
188-
visitNode(cbNode, (<BinaryTypeNode>node).right);
189186
case SyntaxKind.IndexedAccessType:
190187
return visitNode(cbNode, (<IndexedAccessTypeNode>node).objectType) ||
191188
visitNode(cbNode, (<IndexedAccessTypeNode>node).indexType);

‎src/compiler/transformers/ts.ts‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -389,7 +389,6 @@ namespace ts {
389389
case SyntaxKind.ParenthesizedType:
390390
case SyntaxKind.ThisType:
391391
case SyntaxKind.TypeOperator:
392-
case SyntaxKind.BinaryType:
393392
case SyntaxKind.IndexedAccessType:
394393
case SyntaxKind.MappedType:
395394
case SyntaxKind.LiteralType:
@@ -1887,7 +1886,6 @@ namespace ts {
18871886

18881887
case SyntaxKind.TypeQuery:
18891888
case SyntaxKind.TypeOperator:
1890-
case SyntaxKind.BinaryType:
18911889
case SyntaxKind.IndexedAccessType:
18921890
case SyntaxKind.MappedType:
18931891
case SyntaxKind.TypeLiteral:

‎src/compiler/types.ts‎

Lines changed: 7 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -252,7 +252,6 @@ namespace ts {
252252
ParenthesizedType,
253253
ThisType,
254254
TypeOperator,
255-
BinaryType,
256255
IndexedAccessType,
257256
MappedType,
258257
LiteralType,
@@ -1116,13 +1115,6 @@ namespace ts {
11161115
type: TypeNode;
11171116
}
11181117

1119-
export interface BinaryTypeNode extends TypeNode {
1120-
kind: SyntaxKind.BinaryType;
1121-
left: TypeNode;
1122-
operator: SyntaxKind.ExtendsKeyword;
1123-
right: TypeNode;
1124-
}
1125-
11261118
/* @internal */
11271119
export interface UniqueTypeOperatorNode extends TypeOperatorNode {
11281120
operator: SyntaxKind.UniqueKeyword;
@@ -3409,16 +3401,15 @@ namespace ts {
34093401
Index = 1 << 19, // keyof T
34103402
IndexedAccess = 1 << 20, // T[K]
34113403
Conditional = 1 << 21, // T extends U ? X : Y
3412-
Extends = 1 << 22, // T extends U
34133404
/* @internal */
3414-
FreshLiteral = 1 << 23, // Fresh literal or unique type
3405+
FreshLiteral = 1 << 22, // Fresh literal or unique type
34153406
/* @internal */
3416-
ContainsWideningType = 1 << 24, // Type is or contains undefined or null widening type
3407+
ContainsWideningType = 1 << 23, // Type is or contains undefined or null widening type
34173408
/* @internal */
3418-
ContainsObjectLiteral = 1 << 25, // Type is or contains object literal type
3409+
ContainsObjectLiteral = 1 << 24, // Type is or contains object literal type
34193410
/* @internal */
3420-
ContainsAnyFunctionType = 1 << 26, // Type is or contains the anyFunctionType
3421-
NonPrimitive = 1 << 27, // intrinsic object type
3411+
ContainsAnyFunctionType = 1 << 25, // Type is or contains the anyFunctionType
3412+
NonPrimitive = 1 << 26, // intrinsic object type
34223413
/* @internal */
34233414
GenericMappedType = 1 << 29, // Flag used by maybeTypeOfKind
34243415

@@ -3438,14 +3429,14 @@ namespace ts {
34383429
Primitive = String | Number | Boolean | Enum | EnumLiteral | ESSymbol | Void | Undefined | Null | Literal | UniqueESSymbol,
34393430
StringLike = String | StringLiteral | Index,
34403431
NumberLike = Number | NumberLiteral | Enum,
3441-
BooleanLike = Boolean | BooleanLiteral | Extends,
3432+
BooleanLike = Boolean | BooleanLiteral,
34423433
EnumLike = Enum | EnumLiteral,
34433434
ESSymbolLike = ESSymbol | UniqueESSymbol,
34443435
UnionOrIntersection = Union | Intersection,
34453436
StructuredType = Object | Union | Intersection,
34463437
TypeVariable = TypeParameter | IndexedAccess,
34473438
InstantiableNonPrimitive = TypeVariable | Conditional,
3448-
InstantiablePrimitive = Index | Extends,
3439+
InstantiablePrimitive = Index,
34493440
Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
34503441
StructuredOrInstantiable = StructuredType | Instantiable,
34513442

@@ -3709,11 +3700,6 @@ namespace ts {
37093700
falseType: Type;
37103701
}
37113702

3712-
export interface ExtendsType extends InstantiableType {
3713-
checkType: Type;
3714-
extendsType: Type;
3715-
}
3716-
37173703
export const enum SignatureKind {
37183704
Call,
37193705
Construct,

‎src/compiler/utilities.ts‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4549,10 +4549,6 @@ namespace ts {
45494549
return node.kind === SyntaxKind.TypeOperator;
45504550
}
45514551

4552-
export function isBinaryTypeNode(node: Node): node is BinaryTypeNode {
4553-
return node.kind === SyntaxKind.BinaryType;
4554-
}
4555-
45564552
export function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode {
45574553
return node.kind === SyntaxKind.IndexedAccessType;
45584554
}

‎src/compiler/visitor.ts‎

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -400,12 +400,6 @@ namespace ts {
400400
return updateTypeOperatorNode(<TypeOperatorNode>node,
401401
visitNode((<TypeOperatorNode>node).type, visitor, isTypeNode));
402402

403-
case SyntaxKind.BinaryType:
404-
return updateBinaryTypeNode(<BinaryTypeNode>node,
405-
visitNode((<BinaryTypeNode>node).left, visitor, isTypeNode),
406-
(<BinaryTypeNode>node).operator,
407-
visitNode((<BinaryTypeNode>node).right, visitor, isTypeNode));
408-
409403
case SyntaxKind.IndexedAccessType:
410404
return updateIndexedAccessTypeNode((<IndexedAccessTypeNode>node),
411405
visitNode((<IndexedAccessTypeNode>node).objectType, visitor, isTypeNode),

0 commit comments

Comments
 (0)