Skip to content

Commit aa08d39

Browse files
weswighamweswigham
committed
Introduce structural tag T types
1 parent fb453f8 commit aa08d39

27 files changed

+2295
-9
lines changed

Diff for: ‎src/compiler/checker.ts

+63-4
Original file line numberDiff line numberDiff line change
@@ -631,6 +631,7 @@ namespace ts {
631631
const literalTypes = createMap<LiteralType>();
632632
const indexedAccessTypes = createMap<IndexedAccessType>();
633633
const substitutionTypes = createMap<SubstitutionType>();
634+
const structuralTags = createMap<StructuralTagType>();
634635
const evolvingArrayTypes: EvolvingArrayType[] = [];
635636
const undefinedProperties = createMap<Symbol>() as UnderscoreEscapedMap<Symbol>;
636637

@@ -3799,6 +3800,10 @@ namespace ts {
37993800
if (type.flags & TypeFlags.Substitution) {
38003801
return typeToTypeNodeHelper((<SubstitutionType>type).typeVariable, context);
38013802
}
3803+
if (type.flags & TypeFlags.StructuralTag) {
3804+
context.approximateLength += 4;
3805+
return createTypeOperatorNode(SyntaxKind.TagKeyword, typeToTypeNodeHelper((type as StructuralTagType).type, context));
3806+
}
38023807

38033808
return Debug.fail("Should be unreachable.");
38043809

@@ -8103,6 +8108,9 @@ namespace ts {
81038108
if (t.flags & TypeFlags.Substitution) {
81048109
return getBaseConstraint((<SubstitutionType>t).substitute);
81058110
}
8111+
if (t.flags & TypeFlags.StructuralTag) {
8112+
return unknownType;
8113+
}
81068114
return t;
81078115
}
81088116
}
@@ -9924,10 +9932,10 @@ namespace ts {
99249932
return links.resolvedType;
99259933
}
99269934

9927-
function addTypeToIntersection(typeSet: Map<Type>, includes: TypeFlags, type: Type) {
9935+
function addTypeToIntersection(typeSet: Map<Type>, includes: TypeFlags, type: Type, tagSet: Map<StructuralTagType>) {
99289936
const flags = type.flags;
99299937
if (flags & TypeFlags.Intersection) {
9930-
return addTypesToIntersection(typeSet, includes, (<IntersectionType>type).types);
9938+
return addTypesToIntersection(typeSet, includes, (<IntersectionType>type).types, tagSet);
99319939
}
99329940
if (isEmptyAnonymousObjectType(type)) {
99339941
if (!(includes & TypeFlags.IncludesEmptyObject)) {
@@ -9939,6 +9947,9 @@ namespace ts {
99399947
if (flags & TypeFlags.AnyOrUnknown) {
99409948
if (type === wildcardType) includes |= TypeFlags.IncludesWildcard;
99419949
}
9950+
else if (flags & TypeFlags.StructuralTag) {
9951+
tagSet.set(type.id.toString(), type as StructuralTagType);
9952+
}
99429953
else if ((strictNullChecks || !(flags & TypeFlags.Nullable)) && !typeSet.has(type.id.toString())) {
99439954
if (type.flags & TypeFlags.Unit && includes & TypeFlags.Unit) {
99449955
// We have seen two distinct unit types which means we should reduce to an
@@ -9954,9 +9965,23 @@ namespace ts {
99549965

99559966
// Add the given types to the given type set. Order is preserved, freshness is removed from literal
99569967
// types, duplicates are removed, and nested types of the given kind are flattened into the set.
9957-
function addTypesToIntersection(typeSet: Map<Type>, includes: TypeFlags, types: ReadonlyArray<Type>) {
9968+
function addTypesToIntersection(typeSet: Map<Type>, includes: TypeFlags, types: ReadonlyArray<Type>, tagSet?: Map<StructuralTagType> | undefined) {
9969+
const isTopLevel = !tagSet;
9970+
tagSet = tagSet || createMap();
99589971
for (const type of types) {
9959-
includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type));
9972+
includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type), tagSet);
9973+
}
9974+
if (isTopLevel && tagSet.size) {
9975+
let tag: StructuralTagType;
9976+
if (tagSet.size === 1) {
9977+
tag = tagSet.values().next().value;
9978+
}
9979+
else {
9980+
const tagTypes: Type[] = [];
9981+
tagSet.forEach(t => tagTypes.push(t.type));
9982+
tag = getStructuralTagForType(getIntersectionType(tagTypes));
9983+
}
9984+
typeSet.set(tag.id.toString(), tag);
99609985
}
99619986
return includes;
99629987
}
@@ -10258,6 +10283,11 @@ namespace ts {
1025810283
case SyntaxKind.ReadonlyKeyword:
1025910284
links.resolvedType = getTypeFromTypeNode(node.type);
1026010285
break;
10286+
case SyntaxKind.TagKeyword:
10287+
const aliasSymbol = getAliasSymbolForTypeNode(node);
10288+
const aliasParams = getTypeArgumentsForAliasSymbol(aliasSymbol);
10289+
links.resolvedType = getStructuralTagForType(getTypeFromTypeNode(node.type), aliasSymbol, aliasParams);
10290+
break;
1026110291
default:
1026210292
throw Debug.assertNever(node.operator);
1026310293
}
@@ -10272,6 +10302,19 @@ namespace ts {
1027210302
return type;
1027310303
}
1027410304

10305+
function getStructuralTagForType(type: Type, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]) {
10306+
const tid = "" + getTypeId(type);
10307+
if (structuralTags.has(tid)) {
10308+
return structuralTags.get(tid)!;
10309+
}
10310+
const tag = createType(TypeFlags.StructuralTag) as StructuralTagType;
10311+
tag.type = type;
10312+
tag.aliasSymbol = aliasSymbol;
10313+
tag.aliasTypeArguments = aliasTypeArguments;
10314+
structuralTags.set(tid, tag);
10315+
return tag;
10316+
}
10317+
1027510318
/**
1027610319
* Returns if a type is or consists of a JSLiteral object type
1027710320
* In addition to objects which are directly literals,
@@ -11706,6 +11749,10 @@ namespace ts {
1170611749
return sub;
1170711750
}
1170811751
}
11752+
if (flags & TypeFlags.StructuralTag) {
11753+
const newType = instantiateType((type as StructuralTagType).type, mapper);
11754+
return newType !== type ? getStructuralTagForType(newType, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type;
11755+
}
1170911756
return type;
1171011757
}
1171111758

@@ -13422,6 +13469,9 @@ namespace ts {
1342213469
if (flags & TypeFlags.Substitution) {
1342313470
return isRelatedTo((<SubstitutionType>source).substitute, (<SubstitutionType>target).substitute, /*reportErrors*/ false);
1342413471
}
13472+
if (flags & TypeFlags.StructuralTag) {
13473+
return isRelatedTo((<StructuralTagType>source).type, (<StructuralTagType>target).type, /*reportErrors*/ false);
13474+
}
1342513475
return Ternary.False;
1342613476
}
1342713477

@@ -13524,6 +13574,12 @@ namespace ts {
1352413574
}
1352513575
}
1352613576
}
13577+
else if (target.flags & TypeFlags.StructuralTag) {
13578+
if (source.flags & TypeFlags.StructuralTag) {
13579+
return isRelatedTo((source as StructuralTagType).type, (target as StructuralTagType).type, reportErrors);
13580+
}
13581+
return Ternary.False;
13582+
}
1352713583

1352813584
if (source.flags & TypeFlags.TypeVariable) {
1352913585
if (source.flags & TypeFlags.IndexedAccess && target.flags & TypeFlags.IndexedAccess) {
@@ -15727,6 +15783,9 @@ namespace ts {
1572715783
inferFromTypes((<IndexType>source).type, (<IndexType>target).type);
1572815784
contravariant = !contravariant;
1572915785
}
15786+
else if (source.flags & TypeFlags.StructuralTag && target.flags & TypeFlags.StructuralTag) {
15787+
inferFromTypes((<StructuralTagType>source).type, (<StructuralTagType>target).type);
15788+
}
1573015789
else if ((isLiteralType(source) || source.flags & TypeFlags.String) && target.flags & TypeFlags.Index) {
1573115790
const empty = createEmptyObjectTypeFromStringLiteral(source);
1573215791
contravariant = !contravariant;

Diff for: ‎src/compiler/factory.ts

+2-2
Original file line numberDiff line numberDiff line change
@@ -876,8 +876,8 @@ namespace ts {
876876
}
877877

878878
export function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
879-
export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
880-
export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | TypeNode, type?: TypeNode) {
879+
export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.TagKeyword, type: TypeNode): TypeOperatorNode;
880+
export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.TagKeyword | TypeNode, type?: TypeNode) {
881881
const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
882882
node.operator = typeof operatorOrType === "number" ? operatorOrType : SyntaxKind.KeyOfKeyword;
883883
node.type = parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type! : operatorOrType);

Diff for: ‎src/compiler/parser.ts

+3-1
Original file line numberDiff line numberDiff line change
@@ -3053,6 +3053,7 @@ namespace ts {
30533053
case SyntaxKind.ReadonlyKeyword:
30543054
case SyntaxKind.SymbolKeyword:
30553055
case SyntaxKind.UniqueKeyword:
3056+
case SyntaxKind.TagKeyword:
30563057
case SyntaxKind.VoidKeyword:
30573058
case SyntaxKind.UndefinedKeyword:
30583059
case SyntaxKind.NullKeyword:
@@ -3140,7 +3141,7 @@ namespace ts {
31403141
return finishNode(postfix);
31413142
}
31423143

3143-
function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
3144+
function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.TagKeyword) {
31443145
const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
31453146
parseExpected(operator);
31463147
node.operator = operator;
@@ -3163,6 +3164,7 @@ namespace ts {
31633164
case SyntaxKind.KeyOfKeyword:
31643165
case SyntaxKind.UniqueKeyword:
31653166
case SyntaxKind.ReadonlyKeyword:
3167+
case SyntaxKind.TagKeyword:
31663168
return parseTypeOperator(operator);
31673169
case SyntaxKind.InferKeyword:
31683170
return parseInferType();

Diff for: ‎src/compiler/scanner.ts

+1
Original file line numberDiff line numberDiff line change
@@ -138,6 +138,7 @@ namespace ts {
138138
async: SyntaxKind.AsyncKeyword,
139139
await: SyntaxKind.AwaitKeyword,
140140
of: SyntaxKind.OfKeyword,
141+
tag: SyntaxKind.TagKeyword,
141142
};
142143

143144
const textToKeyword = createMapFromTemplate(textToKeywordObj);

Diff for: ‎src/compiler/types.ts

+10-2
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,7 @@ namespace ts {
103103
| SyntaxKind.YieldKeyword
104104
| SyntaxKind.AsyncKeyword
105105
| SyntaxKind.AwaitKeyword
106+
| SyntaxKind.TagKeyword
106107
| SyntaxKind.OfKeyword;
107108

108109
export type JsxTokenSyntaxKind =
@@ -277,6 +278,7 @@ namespace ts {
277278
FromKeyword,
278279
GlobalKeyword,
279280
BigIntKeyword,
281+
TagKeyword,
280282
OfKeyword, // LastKeyword and LastToken and LastContextualKeyword
281283

282284
// Parse tree nodes
@@ -1246,7 +1248,7 @@ namespace ts {
12461248

12471249
export interface TypeOperatorNode extends TypeNode {
12481250
kind: SyntaxKind.TypeOperator;
1249-
operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
1251+
operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.TagKeyword;
12501252
type: TypeNode;
12511253
}
12521254

@@ -3984,6 +3986,7 @@ namespace ts {
39843986
Conditional = 1 << 24, // T extends U ? X : Y
39853987
Substitution = 1 << 25, // Type parameter substitution
39863988
NonPrimitive = 1 << 26, // intrinsic object type
3989+
StructuralTag = 1 << 27, // tag T
39873990

39883991
/* @internal */
39893992
AnyOrUnknown = Any | Unknown,
@@ -4013,7 +4016,7 @@ namespace ts {
40134016
UnionOrIntersection = Union | Intersection,
40144017
StructuredType = Object | Union | Intersection,
40154018
TypeVariable = TypeParameter | IndexedAccess,
4016-
InstantiableNonPrimitive = TypeVariable | Conditional | Substitution,
4019+
InstantiableNonPrimitive = TypeVariable | Conditional | Substitution | StructuralTag,
40174020
InstantiablePrimitive = Index,
40184021
Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
40194022
StructuredOrInstantiable = StructuredType | Instantiable,
@@ -4431,6 +4434,11 @@ namespace ts {
44314434
substitute: Type; // Type to substitute for type parameter
44324435
}
44334436

4437+
// Structual tag type, or a `tag T` (TypeFlags.StructuralTag)
4438+
export interface StructuralTagType extends InstantiableType {
4439+
type: Type;
4440+
}
4441+
44344442
/* @internal */
44354443
export const enum JsxReferenceKind {
44364444
Component,

Diff for: ‎tests/baselines/reference/structuralTagTypes.js

+139
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,139 @@
1+
//// [structuralTagTypes.ts]
2+
export type Downcased = string & tag { downcased: void; };
3+
export type Analyzed<T> = T & tag { analyzed: void; };
4+
export type Paired = {
5+
x: number & tag {x: number;};
6+
y: number & tag {y: number;};
7+
};
8+
9+
export function downcase(x: string): Downcased {
10+
return x.toLocaleLowerCase() as Downcased;
11+
}
12+
13+
export function downcaseLit<T extends string>(x: T): T & Downcased {
14+
return x.toLocaleLowerCase() as T & Downcased;
15+
}
16+
17+
export function isDowncase(x: string): x is Downcased {
18+
return null as any;
19+
}
20+
21+
export function analyze<T>(x: T): Analyzed<T> {
22+
return x as Analyzed<T>;
23+
}
24+
25+
export function isAnalyzed<T>(x: T): x is Analyzed<T> {
26+
return Math.random() > 0.33 ? false : true;
27+
}
28+
29+
export function isPaired(x: {x: number, y: number}): x is Paired {
30+
return true;
31+
}
32+
33+
export function makePair(x: number, y: number): Paired {
34+
return {x, y} as Paired;
35+
}
36+
37+
const a = "ok";
38+
export const b = downcase(a);
39+
export const d = downcaseLit(b);
40+
41+
if (isDowncase(d)) {
42+
d;
43+
}
44+
45+
const e = {data: { value: "str" }};
46+
export const f = analyze(e);
47+
if (isAnalyzed(e)) {
48+
e;
49+
}
50+
51+
export const g = makePair(0, 0);
52+
const h = {x: 0, y: 0};
53+
if (isPaired(h)) {
54+
h;
55+
}
56+
57+
58+
//// [structuralTagTypes.js]
59+
"use strict";
60+
exports.__esModule = true;
61+
function downcase(x) {
62+
return x.toLocaleLowerCase();
63+
}
64+
exports.downcase = downcase;
65+
function downcaseLit(x) {
66+
return x.toLocaleLowerCase();
67+
}
68+
exports.downcaseLit = downcaseLit;
69+
function isDowncase(x) {
70+
return null;
71+
}
72+
exports.isDowncase = isDowncase;
73+
function analyze(x) {
74+
return x;
75+
}
76+
exports.analyze = analyze;
77+
function isAnalyzed(x) {
78+
return Math.random() > 0.33 ? false : true;
79+
}
80+
exports.isAnalyzed = isAnalyzed;
81+
function isPaired(x) {
82+
return true;
83+
}
84+
exports.isPaired = isPaired;
85+
function makePair(x, y) {
86+
return { x: x, y: y };
87+
}
88+
exports.makePair = makePair;
89+
var a = "ok";
90+
exports.b = downcase(a);
91+
exports.d = downcaseLit(exports.b);
92+
if (isDowncase(exports.d)) {
93+
exports.d;
94+
}
95+
var e = { data: { value: "str" } };
96+
exports.f = analyze(e);
97+
if (isAnalyzed(e)) {
98+
e;
99+
}
100+
exports.g = makePair(0, 0);
101+
var h = { x: 0, y: 0 };
102+
if (isPaired(h)) {
103+
h;
104+
}
105+
106+
107+
//// [structuralTagTypes.d.ts]
108+
export declare type Downcased = string & tag {
109+
downcased: void;
110+
};
111+
export declare type Analyzed<T> = T & tag {
112+
analyzed: void;
113+
};
114+
export declare type Paired = {
115+
x: number & tag {
116+
x: number;
117+
};
118+
y: number & tag {
119+
y: number;
120+
};
121+
};
122+
export declare function downcase(x: string): Downcased;
123+
export declare function downcaseLit<T extends string>(x: T): T & Downcased;
124+
export declare function isDowncase(x: string): x is Downcased;
125+
export declare function analyze<T>(x: T): Analyzed<T>;
126+
export declare function isAnalyzed<T>(x: T): x is Analyzed<T>;
127+
export declare function isPaired(x: {
128+
x: number;
129+
y: number;
130+
}): x is Paired;
131+
export declare function makePair(x: number, y: number): Paired;
132+
export declare const b: Downcased;
133+
export declare const d: Downcased;
134+
export declare const f: Analyzed<{
135+
data: {
136+
value: string;
137+
};
138+
}>;
139+
export declare const g: Paired;

0 commit comments

Comments
 (0)