microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-15 03:23:08 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge pull request #17633 from Microsoft/indexSignatureMappedType

Browse Source 
Mapped type and string index signature relations
This commit is contained in:
Anders Hejlsberg 2017-08-07 14:17:29 -07:00 committed by GitHub
commit aa0fc0b885
4 changed files with 160 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/compiler/checker.ts
View File

@ -9671,6 +9671,11 @@ namespace ts {
if (sourceInfo) {
return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors);
}
if (isGenericMappedType(source)) {
// A generic mapped type { [P in K]: T } is related to an index signature { [x: string]: U }
// if T is related to U.
return kind === IndexKind.String && isRelatedTo(getTemplateTypeFromMappedType(<MappedType>source), targetInfo.type, reportErrors);
}
if (isObjectLiteralType(source)) {
let related = Ternary.True;
if (kind === IndexKind.String) {

47
tests/baselines/reference/indexSignatureAndMappedType.errors.txt Normal file
View File

@ -0,0 +1,47 @@
tests/cases/compiler/indexSignatureAndMappedType.ts(6,5): error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, T>'.
tests/cases/compiler/indexSignatureAndMappedType.ts(15,5): error TS2322: Type 'Record<K, U>' is not assignable to type '{ [key: string]: T; }'.
Type 'U' is not assignable to type 'T'.
tests/cases/compiler/indexSignatureAndMappedType.ts(16,5): error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, U>'.
==== tests/cases/compiler/indexSignatureAndMappedType.ts (3 errors) ====
// A mapped type { [P in K]: X }, where K is a generic type, is related to
// { [key: string]: Y } if X is related to Y.
function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
x = y;
y = x; // Error
~
!!! error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, T>'.
}
function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
x = y;
y = x;
}
function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
x = y; // Error
~
!!! error TS2322: Type 'Record<K, U>' is not assignable to type '{ [key: string]: T; }'.
!!! error TS2322: Type 'U' is not assignable to type 'T'.
y = x; // Error
~
!!! error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, U>'.
}
// Repro from #14548
type Dictionary = {
[key: string]: string;
};
interface IBaseEntity {
name: string;
properties: Dictionary;
}
interface IEntity<T extends string> extends IBaseEntity {
properties: Record<T, string>;
}

73
tests/baselines/reference/indexSignatureAndMappedType.js Normal file
View File

@ -0,0 +1,73 @@
//// [indexSignatureAndMappedType.ts]
// A mapped type { [P in K]: X }, where K is a generic type, is related to
// { [key: string]: Y } if X is related to Y.
function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
x = y;
y = x; // Error
}
function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
x = y;
y = x;
}
function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
x = y; // Error
y = x; // Error
}
// Repro from #14548
type Dictionary = {
[key: string]: string;
};
interface IBaseEntity {
name: string;
properties: Dictionary;
}
interface IEntity<T extends string> extends IBaseEntity {
properties: Record<T, string>;
}
//// [indexSignatureAndMappedType.js]
"use strict";
// A mapped type { [P in K]: X }, where K is a generic type, is related to
// { [key: string]: Y } if X is related to Y.
function f1(x, y) {
x = y;
y = x; // Error
}
function f2(x, y) {
x = y;
y = x;
}
function f3(x, y) {
x = y; // Error
y = x; // Error
}
//// [indexSignatureAndMappedType.d.ts]
declare function f1<T, K extends string>(x: {
[key: string]: T;
}, y: Record<K, T>): void;
declare function f2<T>(x: {
[key: string]: T;
}, y: Record<string, T>): void;
declare function f3<T, U, K extends string>(x: {
[key: string]: T;
}, y: Record<K, U>): void;
declare type Dictionary = {
[key: string]: string;
};
interface IBaseEntity {
name: string;
properties: Dictionary;
}
interface IEntity<T extends string> extends IBaseEntity {
properties: Record<T, string>;
}

35
tests/cases/compiler/indexSignatureAndMappedType.ts Normal file
View File

@ -0,0 +1,35 @@
// @strict: true
// @declaration: true
// A mapped type { [P in K]: X }, where K is a generic type, is related to
// { [key: string]: Y } if X is related to Y.
function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
x = y;
y = x; // Error
}
function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
x = y;
y = x;
}
function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
x = y; // Error
y = x; // Error
}
// Repro from #14548
type Dictionary = {
[key: string]: string;
};
interface IBaseEntity {
name: string;
properties: Dictionary;
}
interface IEntity<T extends string> extends IBaseEntity {
properties: Record<T, string>;
}