microsoft
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+6-3Lines changed: 6 additions & 3 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+6-3Lines changed: 6 additions & 3 deletions
diff --git a/‎src/compiler/core.ts
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎src/compiler/core.ts
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎src/harness/harnessGlobals.ts
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎src/harness/harnessGlobals.ts
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎src/services/shims.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/services/shims.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎tests/baselines/reference/isomorphicMappedTypeInference.js
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎tests/baselines/reference/isomorphicMappedTypeInference.js
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎tests/baselines/reference/isomorphicMappedTypeInference.symbols
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎tests/baselines/reference/isomorphicMappedTypeInference.symbols
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎tests/baselines/reference/isomorphicMappedTypeInference.types
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎tests/baselines/reference/isomorphicMappedTypeInference.types
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
@@ -18702,6 +18702,9 @@ namespace ts {
                     return;
                 }
                 reportRelationError(headMessage, source, target);
+                if (strictNullChecks && source.flags & TypeFlags.TypeVariable && source.symbol?.declarations?.[0] && !getConstraintOfType(source as TypeVariable) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive))) {
+                    associateRelatedInfo(createDiagnosticForNode(source.symbol.declarations[0], Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                }
             }
 
             function traceUnionsOrIntersectionsTooLarge(source: Type, target: Type): void {
@@ -19492,20 +19495,20 @@ namespace ts {
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & TypeFlags.IndexedAccess && targetFlags & TypeFlags.IndexedAccess)) {
                         const constraint = getConstraintOfType(source as TypeVariable);
-                        if (!constraint || (sourceFlags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any)) {
+                        if (!strictNullChecks && (!constraint || (sourceFlags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any))) {
                             // A type variable with no constraint is not related to the non-primitive object type.
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive), RecursionFlags.Both)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
-                        else if (result = isRelatedTo(constraint, target, RecursionFlags.Source, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                        else if (constraint && (result = isRelatedTo(constraint, target, RecursionFlags.Source, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, RecursionFlags.Source, reportErrors && !(targetFlags & sourceFlags & TypeFlags.TypeParameter), /*headMessage*/ undefined, intersectionState)) {
+                        else if (constraint && (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, RecursionFlags.Source, reportErrors && !(targetFlags & sourceFlags & TypeFlags.TypeParameter), /*headMessage*/ undefined, intersectionState))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
 
@@ -301,7 +301,7 @@ namespace ts {
         array.length = outIndex;
     }
 
-    export function clear(array: {}[]): void {
+    export function clear(array: unknown[]): void {
         array.length = 0;
     }
 
@@ -1644,7 +1644,7 @@ namespace ts {
     /**
      * Tests whether a value is an array.
      */
-    export function isArray(value: any): value is readonly {}[] {
+    export function isArray(value: any): value is readonly unknown[] {
         return Array.isArray ? Array.isArray(value) : value instanceof Array;
     }
 
@@ -1677,7 +1677,7 @@ namespace ts {
     }
 
     /** Does nothing. */
-    export function noop(_?: {} | null | undefined): void { }
+    export function noop(_?: unknown): void { }
 
     /** Do nothing and return false */
     export function returnFalse(): false {
 
@@ -1506,6 +1506,10 @@
         "category": "Error",
         "code": 2207
     },
+    "This type parameter probably needs an `extends object` constraint.": {
+        "category": "Error",
+        "code": 2208
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",
 
@@ -20,8 +20,8 @@ globalThis.assert = _chai.assert;
         }
         assertDeepImpl(a, b, msg);
 
-        function arrayExtraKeysObject(a: readonly ({} | null | undefined)[]): object {
-            const obj: { [key: string]: {} | null | undefined } = {};
+        function arrayExtraKeysObject(a: readonly unknown[]): object {
+            const obj: { [key: string]: unknown } = {};
             for (const key in a) {
                 if (Number.isNaN(Number(key))) {
                     obj[key] = a[key];
 
@@ -554,7 +554,7 @@ namespace ts {
         }
     }
 
-    function simpleForwardCall(logger: Logger, actionDescription: string, action: () => {}, logPerformance: boolean): {} {
+    function simpleForwardCall(logger: Logger, actionDescription: string, action: () => unknown, logPerformance: boolean): unknown {
         let start: number | undefined;
         if (logPerformance) {
             logger.log(actionDescription);
 
@@ -23,7 +23,7 @@ function boxify<T>(obj: T): Boxified<T> {
     return result;
 }
 
-function unboxify<T>(obj: Boxified<T>): T {
+function unboxify<T extends object>(obj: Boxified<T>): T {
     let result = {} as T;
     for (let k in obj) {
         result[k] = unbox(obj[k]);
@@ -307,7 +307,7 @@ declare type Boxified<T> = {
 declare function box<T>(x: T): Box<T>;
 declare function unbox<T>(x: Box<T>): T;
 declare function boxify<T>(obj: T): Boxified<T>;
-declare function unboxify<T>(obj: Boxified<T>): T;
+declare function unboxify<T extends object>(obj: Boxified<T>): T;
 declare function assignBoxified<T>(obj: Boxified<T>, values: T): void;
 declare function f1(): void;
 declare function f2(): void;
 
@@ -75,10 +75,10 @@ function boxify<T>(obj: T): Boxified<T> {
 >result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 17, 7))
 }
 
-function unboxify<T>(obj: Boxified<T>): T {
+function unboxify<T extends object>(obj: Boxified<T>): T {
 >unboxify : Symbol(unboxify, Decl(isomorphicMappedTypeInference.ts, 22, 1))
 >T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18))
->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21))
+>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 36))
 >Boxified : Symbol(Boxified, Decl(isomorphicMappedTypeInference.ts, 2, 1))
 >T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18))
 >T : Symbol(T, Decl(isomorphicMappedTypeInference.ts, 24, 18))
@@ -89,13 +89,13 @@ function unboxify<T>(obj: Boxified<T>): T {
 
     for (let k in obj) {
 >k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12))
->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21))
+>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 36))
 
         result[k] = unbox(obj[k]);
 >result : Symbol(result, Decl(isomorphicMappedTypeInference.ts, 25, 7))
 >k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12))
 >unbox : Symbol(unbox, Decl(isomorphicMappedTypeInference.ts, 10, 1))
->obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 21))
+>obj : Symbol(obj, Decl(isomorphicMappedTypeInference.ts, 24, 36))
 >k : Symbol(k, Decl(isomorphicMappedTypeInference.ts, 26, 12))
     }
     return result;
 
@@ -60,8 +60,8 @@ function boxify<T>(obj: T): Boxified<T> {
 >result : Boxified<T>
 }
 
-function unboxify<T>(obj: Boxified<T>): T {
->unboxify : <T>(obj: Boxified<T>) => T
+function unboxify<T extends object>(obj: Boxified<T>): T {
+>unboxify : <T extends object>(obj: Boxified<T>) => T
 >obj : Boxified<T>
 
     let result = {} as T;
@@ -174,7 +174,7 @@ function f2() {
     let v = unboxify(b);
 >v : { a: number; b: string; c: boolean; }
 >unboxify(b) : { a: number; b: string; c: boolean; }
->unboxify : <T>(obj: Boxified<T>) => T
+>unboxify : <T extends object>(obj: Boxified<T>) => T
 >b : { a: Box<number>; b: Box<string>; c: Box<boolean>; }
 
     let x: number = v.a;
@@ -251,14 +251,14 @@ function f4() {
 >boxify(unboxify(b)) : Boxified<{ a: number; b: string; c: boolean; }>
 >boxify : <T>(obj: T) => Boxified<T>
 >unboxify(b) : { a: number; b: string; c: boolean; }
->unboxify : <T>(obj: Boxified<T>) => T
+>unboxify : <T extends object>(obj: Boxified<T>) => T
 >b : { a: Box<number>; b: Box<string>; c: Box<boolean>; }
 
     b = unboxify(boxify(b));
 >b = unboxify(boxify(b)) : { a: Box<number>; b: Box<string>; c: Box<boolean>; }
 >b : { a: Box<number>; b: Box<string>; c: Box<boolean>; }
 >unboxify(boxify(b)) : { a: Box<number>; b: Box<string>; c: Box<boolean>; }
->unboxify : <T>(obj: Boxified<T>) => T
+>unboxify : <T extends object>(obj: Boxified<T>) => T
 >boxify(b) : Boxified<{ a: Box<number>; b: Box<string>; c: Box<boolean>; }>
 >boxify : <T>(obj: T) => Boxified<T>
 >b : { a: Box<number>; b: Box<string>; c: Box<boolean>; }
@@ -304,7 +304,7 @@ function f5(s: string) {
     let v = unboxify(b);
 >v : { a: string | number | boolean; b: string | number | boolean; c: string | number | boolean; }
 >unboxify(b) : { a: string | number | boolean; b: string | number | boolean; c: string | number | boolean; }
->unboxify : <T>(obj: Boxified<T>) => T
+>unboxify : <T extends object>(obj: Boxified<T>) => T
 >b : { a: Box<number> | Box<string> | Box<boolean>; b: Box<number> | Box<string> | Box<boolean>; c: Box<number> | Box<string> | Box<boolean>; }
 
     let x: string | number | boolean = v.a;
@@ -355,7 +355,7 @@ function f6(s: string) {
     let v = unboxify(b);
 >v : { [x: string]: any; }
 >unboxify(b) : { [x: string]: any; }
->unboxify : <T>(obj: Boxified<T>) => T
+>unboxify : <T extends object>(obj: Boxified<T>) => T
 >b : { [x: string]: Box<number> | Box<string> | Box<boolean>; }
 
     let x: string | number | boolean = v[s];
Original file line number	Diff line number	Diff line change
`@@ -18702,6 +18702,9 @@ namespace ts {`
`18702`	`18702`	`return;`
`18703`	`18703`	`}`
`18704`	`18704`	`reportRelationError(headMessage, source, target);`
	`18705`	`+ if (strictNullChecks && source.flags & TypeFlags.TypeVariable && source.symbol?.declarations?.[0] && !getConstraintOfType(source as TypeVariable) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive))) {`
	`18706`	`+ associateRelatedInfo(createDiagnosticForNode(source.symbol.declarations[0], Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));`
	`18707`	`+ }`
`18705`	`18708`	`}`
`18706`	`18709`
`18707`	`18710`	`function traceUnionsOrIntersectionsTooLarge(source: Type, target: Type): void {`
`@@ -19492,20 +19495,20 @@ namespace ts {`
`19492`	`19495`	// IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
`19493`	`19496`	`if (!(sourceFlags & TypeFlags.IndexedAccess && targetFlags & TypeFlags.IndexedAccess)) {`
`19494`	`19497`	`const constraint = getConstraintOfType(source as TypeVariable);`
`19495`		`- if (!constraint \|\| (sourceFlags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any)) {`
	`19498`	`+ if (!strictNullChecks && (!constraint \|\| (sourceFlags & TypeFlags.TypeParameter && constraint.flags & TypeFlags.Any))) {`
`19496`	`19499`	`// A type variable with no constraint is not related to the non-primitive object type.`
`19497`	`19500`	`if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~TypeFlags.NonPrimitive), RecursionFlags.Both)) {`
`19498`	`19501`	`resetErrorInfo(saveErrorInfo);`
`19499`	`19502`	`return result;`
`19500`	`19503`	`}`
`19501`	`19504`	`}`
`19502`	`19505`	// hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
`19503`		`- else if (result = isRelatedTo(constraint, target, RecursionFlags.Source, /reportErrors/ false, /headMessage/ undefined, intersectionState)) {`
	`19506`	`+ else if (constraint && (result = isRelatedTo(constraint, target, RecursionFlags.Source, /reportErrors/ false, /headMessage/ undefined, intersectionState))) {`
`19504`	`19507`	`resetErrorInfo(saveErrorInfo);`
`19505`	`19508`	`return result;`
`19506`	`19509`	`}`
`19507`	`19510`	// slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
`19508`		`- else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, RecursionFlags.Source, reportErrors && !(targetFlags & sourceFlags & TypeFlags.TypeParameter), /headMessage/ undefined, intersectionState)) {`
	`19511`	`+ else if (constraint && (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, RecursionFlags.Source, reportErrors && !(targetFlags & sourceFlags & TypeFlags.TypeParameter), /headMessage/ undefined, intersectionState))) {`
`19509`	`19512`	`resetErrorInfo(saveErrorInfo);`
`19510`	`19513`	`return result;`
`19511`	`19514`	`}`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ namespace ts {`
`301`	`301`	`array.length = outIndex;`
`302`	`302`	`}`
`303`	`303`
`304`		`- export function clear(array: {}[]): void {`
	`304`	`+ export function clear(array: unknown[]): void {`
`305`	`305`	`array.length = 0;`
`306`	`306`	`}`
`307`	`307`
`@@ -1644,7 +1644,7 @@ namespace ts {`
`1644`	`1644`	`/**`
`1645`	`1645`	`* Tests whether a value is an array.`
`1646`	`1646`	`*/`
`1647`		`- export function isArray(value: any): value is readonly {}[] {`
	`1647`	`+ export function isArray(value: any): value is readonly unknown[] {`
`1648`	`1648`	`return Array.isArray ? Array.isArray(value) : value instanceof Array;`
`1649`	`1649`	`}`
`1650`	`1650`
`@@ -1677,7 +1677,7 @@ namespace ts {`
`1677`	`1677`	`}`
`1678`	`1678`
`1679`	`1679`	`/** Does nothing. */`
`1680`		`- export function noop(_?: {} \| null \| undefined): void { }`
	`1680`	`+ export function noop(_?: unknown): void { }`
`1681`	`1681`
`1682`	`1682`	`/** Do nothing and return false */`
`1683`	`1683`	`export function returnFalse(): false {`
Original file line number	Diff line number	Diff line change
`@@ -554,7 +554,7 @@ namespace ts {`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`
`557`		`- function simpleForwardCall(logger: Logger, actionDescription: string, action: () => {}, logPerformance: boolean): {} {`
	`557`	`+ function simpleForwardCall(logger: Logger, actionDescription: string, action: () => unknown, logPerformance: boolean): unknown {`
`558`	`558`	`let start: number \| undefined;`
`559`	`559`	`if (logPerformance) {`
`560`	`560`	`logger.log(actionDescription);`