Skip to content

Commit 151bc59

Browse files
ahejlsbergtypescript-bot
ahejlsberg
authored and
typescript-bot
committed
Cherry-pick PR microsoft#44219 into release-4.3
Component commits: 4475012 Improve getNonNullableType function 86f09ae Add tests d45806a More closely match previous behavior 634b01a Add non-strict mode test
1 parent d6e6fa7 commit 151bc59

9 files changed

+332
-6
lines changed

‎src/compiler/checker.ts

Lines changed: 9 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -20239,14 +20239,17 @@ namespace ts {
2023920239
}
2024020240

2024120241
function getGlobalNonNullableTypeInstantiation(type: Type) {
20242+
// First reduce away any constituents that are assignable to 'undefined' or 'null'. This not only eliminates
20243+
// 'undefined' and 'null', but also higher-order types such as a type parameter 'U extends undefined | null'
20244+
// that isn't eliminated by a NonNullable<T> instantiation.
20245+
const reducedType = getTypeWithFacts(type, TypeFacts.NEUndefinedOrNull);
2024220246
if (!deferredGlobalNonNullableTypeAlias) {
2024320247
deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable" as __String, SymbolFlags.TypeAlias, /*diagnostic*/ undefined) || unknownSymbol;
2024420248
}
20245-
// Use NonNullable global type alias if available to improve quick info/declaration emit
20246-
if (deferredGlobalNonNullableTypeAlias !== unknownSymbol) {
20247-
return getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]);
20248-
}
20249-
return getTypeWithFacts(type, TypeFacts.NEUndefinedOrNull); // Type alias unavailable, fall back to non-higher-order behavior
20249+
// If the NonNullable<T> type is available, return an instantiation. Otherwise just return the reduced type.
20250+
return deferredGlobalNonNullableTypeAlias !== unknownSymbol ?
20251+
getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
20252+
reducedType;
2025020253
}
2025120254

2025220255
function getNonNullableType(type: Type): Type {
@@ -24035,7 +24038,7 @@ namespace ts {
2403524038
}
2403624039

2403724040
function isGenericTypeWithUnionConstraint(type: Type) {
24038-
return !!(type.flags & TypeFlags.Instantiable && getBaseConstraintOrType(type).flags & TypeFlags.Union);
24041+
return !!(type.flags & TypeFlags.Instantiable && getBaseConstraintOrType(type).flags & (TypeFlags.Nullable | TypeFlags.Union));
2403924042
}
2404024043

2404124044
function containsGenericType(type: Type): boolean {

‎tests/baselines/reference/nonNullableReduction.js

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
//// [nonNullableReduction.ts]
2+
// Repros from #43425
3+
4+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
5+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
6+
7+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
8+
f1?.("hello");
9+
f2?.("hello");
10+
}
11+
12+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
13+
let z = x!; // NonNullable<T>
14+
}
15+
16+
function f2<T, U extends null | undefined>(x: T | U) {
17+
let z = x!; // NonNullable<T>
18+
}
19+
20+
21+
//// [nonNullableReduction.js]
22+
"use strict";
23+
// Repros from #43425
24+
function test(f1, f2) {
25+
f1 === null || f1 === void 0 ? void 0 : f1("hello");
26+
f2 === null || f2 === void 0 ? void 0 : f2("hello");
27+
}
28+
function f1(x) {
29+
var z = x; // NonNullable<T>
30+
}
31+
function f2(x) {
32+
var z = x; // NonNullable<T>
33+
}

‎tests/baselines/reference/nonNullableReduction.symbols

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
=== tests/cases/compiler/nonNullableReduction.ts ===
2+
// Repros from #43425
3+
4+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
5+
>Transform1 : Symbol(Transform1, Decl(nonNullableReduction.ts, 0, 0))
6+
>T : Symbol(T, Decl(nonNullableReduction.ts, 2, 16))
7+
>value : Symbol(value, Decl(nonNullableReduction.ts, 2, 23))
8+
>T : Symbol(T, Decl(nonNullableReduction.ts, 2, 16))
9+
>T : Symbol(T, Decl(nonNullableReduction.ts, 2, 16))
10+
11+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
12+
>Transform2 : Symbol(Transform2, Decl(nonNullableReduction.ts, 2, 85))
13+
>T : Symbol(T, Decl(nonNullableReduction.ts, 3, 16))
14+
>T : Symbol(T, Decl(nonNullableReduction.ts, 3, 16))
15+
>value : Symbol(value, Decl(nonNullableReduction.ts, 3, 42))
16+
>T : Symbol(T, Decl(nonNullableReduction.ts, 3, 16))
17+
>value : Symbol(value, Decl(nonNullableReduction.ts, 3, 78))
18+
>T : Symbol(T, Decl(nonNullableReduction.ts, 3, 16))
19+
20+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
21+
>test : Symbol(test, Decl(nonNullableReduction.ts, 3, 98))
22+
>T : Symbol(T, Decl(nonNullableReduction.ts, 5, 14))
23+
>f1 : Symbol(f1, Decl(nonNullableReduction.ts, 5, 17))
24+
>Transform1 : Symbol(Transform1, Decl(nonNullableReduction.ts, 0, 0))
25+
>T : Symbol(T, Decl(nonNullableReduction.ts, 5, 14))
26+
>f2 : Symbol(f2, Decl(nonNullableReduction.ts, 5, 35))
27+
>Transform2 : Symbol(Transform2, Decl(nonNullableReduction.ts, 2, 85))
28+
>T : Symbol(T, Decl(nonNullableReduction.ts, 5, 14))
29+
30+
f1?.("hello");
31+
>f1 : Symbol(f1, Decl(nonNullableReduction.ts, 5, 17))
32+
33+
f2?.("hello");
34+
>f2 : Symbol(f2, Decl(nonNullableReduction.ts, 5, 35))
35+
}
36+
37+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
38+
>f1 : Symbol(f1, Decl(nonNullableReduction.ts, 8, 1))
39+
>T : Symbol(T, Decl(nonNullableReduction.ts, 10, 12))
40+
>x : Symbol(x, Decl(nonNullableReduction.ts, 10, 15))
41+
>T : Symbol(T, Decl(nonNullableReduction.ts, 10, 12))
42+
>T : Symbol(T, Decl(nonNullableReduction.ts, 10, 12))
43+
44+
let z = x!; // NonNullable<T>
45+
>z : Symbol(z, Decl(nonNullableReduction.ts, 11, 7))
46+
>x : Symbol(x, Decl(nonNullableReduction.ts, 10, 15))
47+
}
48+
49+
function f2<T, U extends null | undefined>(x: T | U) {
50+
>f2 : Symbol(f2, Decl(nonNullableReduction.ts, 12, 1))
51+
>T : Symbol(T, Decl(nonNullableReduction.ts, 14, 12))
52+
>U : Symbol(U, Decl(nonNullableReduction.ts, 14, 14))
53+
>x : Symbol(x, Decl(nonNullableReduction.ts, 14, 43))
54+
>T : Symbol(T, Decl(nonNullableReduction.ts, 14, 12))
55+
>U : Symbol(U, Decl(nonNullableReduction.ts, 14, 14))
56+
57+
let z = x!; // NonNullable<T>
58+
>z : Symbol(z, Decl(nonNullableReduction.ts, 15, 7))
59+
>x : Symbol(x, Decl(nonNullableReduction.ts, 14, 43))
60+
}
61+

‎tests/baselines/reference/nonNullableReduction.types

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
=== tests/cases/compiler/nonNullableReduction.ts ===
2+
// Repros from #43425
3+
4+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
5+
>Transform1 : Transform1<T>
6+
>value : string
7+
8+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
9+
>Transform2 : Transform2<T>
10+
>value : string
11+
>value : string
12+
13+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
14+
>test : <T>(f1: Transform1<T>, f2: Transform2<T>) => void
15+
>f1 : Transform1<T>
16+
>f2 : Transform2<T>
17+
18+
f1?.("hello");
19+
>f1?.("hello") : T | undefined
20+
>f1 : ((value: string) => T) | undefined
21+
>"hello" : "hello"
22+
23+
f2?.("hello");
24+
>f2?.("hello") : T | undefined
25+
>f2 : ((value: string) => T) | ((value: string) => T) | undefined
26+
>"hello" : "hello"
27+
}
28+
29+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
30+
>f1 : <T>(x: T | (string extends T ? null | undefined : never)) => void
31+
>x : T | (string extends T ? null | undefined : never)
32+
>null : null
33+
34+
let z = x!; // NonNullable<T>
35+
>z : NonNullable<T>
36+
>x! : NonNullable<T>
37+
>x : T | (string extends T ? null | undefined : never)
38+
}
39+
40+
function f2<T, U extends null | undefined>(x: T | U) {
41+
>f2 : <T, U extends null | undefined>(x: T | U) => void
42+
>null : null
43+
>x : T | U
44+
45+
let z = x!; // NonNullable<T>
46+
>z : NonNullable<T>
47+
>x! : NonNullable<T>
48+
>x : T | U
49+
}
50+

‎tests/baselines/reference/nonNullableReductionNonStrict.js

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
//// [nonNullableReductionNonStrict.ts]
2+
// Repros from #43425
3+
4+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
5+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
6+
7+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
8+
f1?.("hello");
9+
f2?.("hello");
10+
}
11+
12+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
13+
let z = x!; // NonNullable<T>
14+
}
15+
16+
function f2<T, U extends null | undefined>(x: T | U) {
17+
let z = x!; // NonNullable<T>
18+
}
19+
20+
21+
//// [nonNullableReductionNonStrict.js]
22+
// Repros from #43425
23+
function test(f1, f2) {
24+
f1 === null || f1 === void 0 ? void 0 : f1("hello");
25+
f2 === null || f2 === void 0 ? void 0 : f2("hello");
26+
}
27+
function f1(x) {
28+
var z = x; // NonNullable<T>
29+
}
30+
function f2(x) {
31+
var z = x; // NonNullable<T>
32+
}

‎tests/baselines/reference/nonNullableReductionNonStrict.symbols

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
=== tests/cases/compiler/nonNullableReductionNonStrict.ts ===
2+
// Repros from #43425
3+
4+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
5+
>Transform1 : Symbol(Transform1, Decl(nonNullableReductionNonStrict.ts, 0, 0))
6+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 2, 16))
7+
>value : Symbol(value, Decl(nonNullableReductionNonStrict.ts, 2, 23))
8+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 2, 16))
9+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 2, 16))
10+
11+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
12+
>Transform2 : Symbol(Transform2, Decl(nonNullableReductionNonStrict.ts, 2, 85))
13+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 3, 16))
14+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 3, 16))
15+
>value : Symbol(value, Decl(nonNullableReductionNonStrict.ts, 3, 42))
16+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 3, 16))
17+
>value : Symbol(value, Decl(nonNullableReductionNonStrict.ts, 3, 78))
18+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 3, 16))
19+
20+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
21+
>test : Symbol(test, Decl(nonNullableReductionNonStrict.ts, 3, 98))
22+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 5, 14))
23+
>f1 : Symbol(f1, Decl(nonNullableReductionNonStrict.ts, 5, 17))
24+
>Transform1 : Symbol(Transform1, Decl(nonNullableReductionNonStrict.ts, 0, 0))
25+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 5, 14))
26+
>f2 : Symbol(f2, Decl(nonNullableReductionNonStrict.ts, 5, 35))
27+
>Transform2 : Symbol(Transform2, Decl(nonNullableReductionNonStrict.ts, 2, 85))
28+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 5, 14))
29+
30+
f1?.("hello");
31+
>f1 : Symbol(f1, Decl(nonNullableReductionNonStrict.ts, 5, 17))
32+
33+
f2?.("hello");
34+
>f2 : Symbol(f2, Decl(nonNullableReductionNonStrict.ts, 5, 35))
35+
}
36+
37+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
38+
>f1 : Symbol(f1, Decl(nonNullableReductionNonStrict.ts, 8, 1))
39+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 10, 12))
40+
>x : Symbol(x, Decl(nonNullableReductionNonStrict.ts, 10, 15))
41+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 10, 12))
42+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 10, 12))
43+
44+
let z = x!; // NonNullable<T>
45+
>z : Symbol(z, Decl(nonNullableReductionNonStrict.ts, 11, 7))
46+
>x : Symbol(x, Decl(nonNullableReductionNonStrict.ts, 10, 15))
47+
}
48+
49+
function f2<T, U extends null | undefined>(x: T | U) {
50+
>f2 : Symbol(f2, Decl(nonNullableReductionNonStrict.ts, 12, 1))
51+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 14, 12))
52+
>U : Symbol(U, Decl(nonNullableReductionNonStrict.ts, 14, 14))
53+
>x : Symbol(x, Decl(nonNullableReductionNonStrict.ts, 14, 43))
54+
>T : Symbol(T, Decl(nonNullableReductionNonStrict.ts, 14, 12))
55+
>U : Symbol(U, Decl(nonNullableReductionNonStrict.ts, 14, 14))
56+
57+
let z = x!; // NonNullable<T>
58+
>z : Symbol(z, Decl(nonNullableReductionNonStrict.ts, 15, 7))
59+
>x : Symbol(x, Decl(nonNullableReductionNonStrict.ts, 14, 43))
60+
}
61+

‎tests/baselines/reference/nonNullableReductionNonStrict.types

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
=== tests/cases/compiler/nonNullableReductionNonStrict.ts ===
2+
// Repros from #43425
3+
4+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
5+
>Transform1 : Transform1<T>
6+
>value : string
7+
8+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
9+
>Transform2 : Transform2<T>
10+
>value : string
11+
>value : string
12+
13+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
14+
>test : <T>(f1: Transform1<T>, f2: Transform2<T>) => void
15+
>f1 : Transform1<T>
16+
>f2 : Transform2<T>
17+
18+
f1?.("hello");
19+
>f1?.("hello") : T
20+
>f1 : (value: string) => T
21+
>"hello" : "hello"
22+
23+
f2?.("hello");
24+
>f2?.("hello") : T
25+
>f2 : ((value: string) => T) | ((value: string) => T)
26+
>"hello" : "hello"
27+
}
28+
29+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
30+
>f1 : <T>(x: T | (string extends T ? null | undefined : never)) => void
31+
>x : T | (string extends T ? null : never)
32+
>null : null
33+
34+
let z = x!; // NonNullable<T>
35+
>z : T | (string extends T ? null : never)
36+
>x! : T | (string extends T ? null : never)
37+
>x : T | (string extends T ? null : never)
38+
}
39+
40+
function f2<T, U extends null | undefined>(x: T | U) {
41+
>f2 : <T, U extends null>(x: T | U) => void
42+
>null : null
43+
>x : T | U
44+
45+
let z = x!; // NonNullable<T>
46+
>z : T | U
47+
>x! : T | U
48+
>x : T | U
49+
}
50+

‎tests/cases/compiler/nonNullableReduction.ts

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
// @strict: true
2+
3+
// Repros from #43425
4+
5+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
6+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
7+
8+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
9+
f1?.("hello");
10+
f2?.("hello");
11+
}
12+
13+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
14+
let z = x!; // NonNullable<T>
15+
}
16+
17+
function f2<T, U extends null | undefined>(x: T | U) {
18+
let z = x!; // NonNullable<T>
19+
}

‎tests/cases/compiler/nonNullableReductionNonStrict.ts

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
// Repros from #43425
2+
3+
type Transform1<T> = ((value: string) => T) | (string extends T ? undefined : never);
4+
type Transform2<T> = string extends T ? ((value: string) => T) | undefined : (value: string) => T;
5+
6+
function test<T>(f1: Transform1<T>, f2: Transform2<T>) {
7+
f1?.("hello");
8+
f2?.("hello");
9+
}
10+
11+
function f1<T>(x: T | (string extends T ? null | undefined : never)) {
12+
let z = x!; // NonNullable<T>
13+
}
14+
15+
function f2<T, U extends null | undefined>(x: T | U) {
16+
let z = x!; // NonNullable<T>
17+
}

0 commit comments

Comments
 (0)