Merge pull request #12368 from Microsoft/Port12351-3

Port #12351  to release-2.1

Author: mhegazy

src/compiler/checker.ts

@@ -120,6 +120,7 @@ namespace ts {
         const intersectionTypes = createMap<IntersectionType>();
         const stringLiteralTypes = createMap<LiteralType>();
         const numericLiteralTypes = createMap<LiteralType>();
+        const indexedAccessTypes = createMap<IndexedAccessType>();
         const evolvingArrayTypes: EvolvingArrayType[] = [];
 
         const unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
@@ -4665,13 +4666,22 @@ namespace ts {
             return type.resolvedApparentType;
         }
 
+        /**
+         * The apparent type of an indexed access T[K] is the type of T's string index signature, if any.
+         */
+        function getApparentTypeOfIndexedAccess(type: IndexedAccessType) {
+            return getIndexTypeOfType(getApparentType(type.objectType), IndexKind.String) || type;
+        }
+
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself. Note that the apparent type of a union type is the union type itself.
          */
         function getApparentType(type: Type): Type {
-            const t = type.flags & TypeFlags.TypeParameter ? getApparentTypeOfTypeParameter(<TypeParameter>type) : type;
+            const t = type.flags & TypeFlags.TypeParameter ? getApparentTypeOfTypeParameter(<TypeParameter>type) :
+                type.flags & TypeFlags.IndexedAccess ? getApparentTypeOfIndexedAccess(<IndexedAccessType>type) :
+                type;
             return t.flags & TypeFlags.StringLike ? globalStringType :
                 t.flags & TypeFlags.NumberLike ? globalNumberType :
                 t.flags & TypeFlags.BooleanLike ? globalBooleanType :
@@ -5907,6 +5917,7 @@ namespace ts {
 
         function getIndexType(type: Type): Type {
             return type.flags & TypeFlags.TypeParameter ? getIndexTypeForTypeParameter(<TypeParameter>type) :
+                getObjectFlags(type) & ObjectFlags.Mapped ? getConstraintTypeFromMappedType(<MappedType>type) :
                 type.flags & TypeFlags.Any || getIndexInfoOfType(type, IndexKind.String) ? stringOrNumberType :
                 getIndexInfoOfType(type, IndexKind.Number) ? getUnionType([numberType, getLiteralTypeFromPropertyNames(type)]) :
                 getLiteralTypeFromPropertyNames(type);
@@ -5920,18 +5931,13 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function createIndexedAccessType(objectType: Type, indexType: TypeParameter) {
+        function createIndexedAccessType(objectType: Type, indexType: Type) {
             const type = <IndexedAccessType>createType(TypeFlags.IndexedAccess);
             type.objectType = objectType;
             type.indexType = indexType;
             return type;
         }
 
-        function getIndexedAccessTypeForTypeParameter(objectType: Type, indexType: TypeParameter) {
-            const indexedAccessTypes = indexType.resolvedIndexedAccessTypes || (indexType.resolvedIndexedAccessTypes = []);
-            return indexedAccessTypes[objectType.id] || (indexedAccessTypes[objectType.id] = createIndexedAccessType(objectType, indexType));
-        }
-
         function getPropertyTypeForIndexType(objectType: Type, indexType: Type, accessNode: ElementAccessExpression | IndexedAccessTypeNode, cacheSymbol: boolean) {
             const accessExpression = accessNode && accessNode.kind === SyntaxKind.ElementAccessExpression ? <ElementAccessExpression>accessNode : undefined;
             const propName = indexType.flags & (TypeFlags.StringLiteral | TypeFlags.NumberLiteral | TypeFlags.EnumLiteral) ?
@@ -5995,13 +6001,41 @@ namespace ts {
             return unknownType;
         }
 
+        function getIndexedAccessForMappedType(type: MappedType, indexType: Type, accessNode?: ElementAccessExpression | IndexedAccessTypeNode) {
+            const accessExpression = accessNode && accessNode.kind === SyntaxKind.ElementAccessExpression ? <ElementAccessExpression>accessNode : undefined;
+            if (accessExpression && isAssignmentTarget(accessExpression) && type.declaration.readonlyToken) {
+                error(accessExpression, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(type));
+                return unknownType;
+            }
+            const mapper = createUnaryTypeMapper(getTypeParameterFromMappedType(type), indexType);
+            const templateMapper = type.mapper ? combineTypeMappers(type.mapper, mapper) : mapper;
+            return addOptionality(instantiateType(getTemplateTypeFromMappedType(type), templateMapper), !!type.declaration.questionToken);
+        }
+
         function getIndexedAccessType(objectType: Type, indexType: Type, accessNode?: ElementAccessExpression | IndexedAccessTypeNode) {
-            if (indexType.flags & TypeFlags.TypeParameter) {
-                if (accessNode && !isTypeAssignableTo(getConstraintOfTypeParameter(<TypeParameter>indexType) || emptyObjectType, getIndexType(objectType))) {
-                    error(accessNode, Diagnostics.Type_0_is_not_constrained_to_keyof_1, typeToString(indexType), typeToString(objectType));
-                    return unknownType;
+            if (indexType.flags & TypeFlags.TypeParameter ||
+                objectType.flags & TypeFlags.TypeParameter && indexType.flags & TypeFlags.Index ||
+                isGenericMappedType(objectType)) {
+                // If either the object type or the index type are type parameters, or if the object type is a mapped
+                // type with a generic constraint, we are performing a higher-order index access where we cannot
+                // meaningfully access the properties of the object type. In those cases, we first check that the
+                // index type is assignable to 'keyof T' for the object type.
+                if (accessNode) {
+                    const keyType = indexType.flags & TypeFlags.TypeParameter ? getConstraintOfTypeParameter(<TypeParameter>indexType) || emptyObjectType : indexType;
+                    if (!isTypeAssignableTo(keyType, getIndexType(objectType))) {
+                        error(accessNode, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));
+                        return unknownType;
+                    }
+                }
+                // If the object type is a mapped type { [P in K]: E }, we instantiate E using a mapper that substitutes
+                // the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the
+                // type Box<T[X]>.
+                if (isGenericMappedType(objectType)) {
+                    return getIndexedAccessForMappedType(<MappedType>objectType, indexType, accessNode);
                 }
-                return getIndexedAccessTypeForTypeParameter(objectType, <TypeParameter>indexType);
+                // Otherwise we defer the operation by creating an indexed access type.
+                const id = objectType.id + "," + indexType.id;
+                return indexedAccessTypes[id] || (indexedAccessTypes[id] = createIndexedAccessType(objectType, indexType));
             }
             const apparentType = getApparentType(objectType);
             if (indexType.flags & TypeFlags.Union && !(indexType.flags & TypeFlags.Primitive)) {
@@ -6034,6 +6068,9 @@ namespace ts {
                 type.aliasSymbol = getAliasSymbolForTypeNode(node);
                 type.aliasTypeArguments = getAliasTypeArgumentsForTypeNode(node);
                 links.resolvedType = type;
+                // Eagerly resolve the constraint type which forces an error if the constraint type circularly
+                // references itself through one or more type aliases.
+                getConstraintTypeFromMappedType(type);
             }
             return links.resolvedType;
         }
@@ -7153,12 +7190,24 @@ namespace ts {
                 }
 
                 if (target.flags & TypeFlags.TypeParameter) {
-                    // Given a type parameter K with a constraint keyof T, a type S is
-                    // assignable to K if S is assignable to keyof T.
-                    const constraint = getConstraintOfTypeParameter(<TypeParameter>target);
-                    if (constraint && constraint.flags & TypeFlags.Index) {
-                        if (result = isRelatedTo(source, constraint, reportErrors)) {
-                            return result;
+                    // A source type { [P in keyof T]: X } is related to a target type T if X is related to T[P].
+                    if (getObjectFlags(source) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(<MappedType>source) === getIndexType(target)) {
+                        if (!(<MappedType>source).declaration.questionToken) {
+                            const templateType = getTemplateTypeFromMappedType(<MappedType>source);
+                            const indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(<MappedType>source));
+                            if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) {
+                                return result;
+                            }
+                        }
+                    }
+                    else {
+                        // Given a type parameter K with a constraint keyof T, a type S is
+                        // assignable to K if S is assignable to keyof T.
+                        const constraint = getConstraintOfTypeParameter(<TypeParameter>target);
+                        if (constraint && constraint.flags & TypeFlags.Index) {
+                            if (result = isRelatedTo(source, constraint, reportErrors)) {
+                                return result;
+                            }
                         }
                     }
                 }
@@ -7178,22 +7227,41 @@ namespace ts {
                         }
                     }
                 }
+                else if (target.flags & TypeFlags.IndexedAccess) {
+                    // if we have indexed access types with identical index types, see if relationship holds for
+                    // the two object types.
+                    if (source.flags & TypeFlags.IndexedAccess && (<IndexedAccessType>source).indexType === (<IndexedAccessType>target).indexType) {
+                        if (result = isRelatedTo((<IndexedAccessType>source).objectType, (<IndexedAccessType>target).objectType, reportErrors)) {
+                            return result;
+                        }
+                    }
+                }
 
                 if (source.flags & TypeFlags.TypeParameter) {
-                    let constraint = getConstraintOfTypeParameter(<TypeParameter>source);
-
-                    if (!constraint || constraint.flags & TypeFlags.Any) {
-                        constraint = emptyObjectType;
+                    // A source type T is related to a target type { [P in keyof T]: X } if T[P] is related to X.
+                    if (getObjectFlags(target) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(<MappedType>target) === getIndexType(source)) {
+                        const indexedAccessType = getIndexedAccessType(source, getTypeParameterFromMappedType(<MappedType>target));
+                        const templateType = getTemplateTypeFromMappedType(<MappedType>target);
+                        if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {
+                            return result;
+                        }
                     }
+                    else {
+                        let constraint = getConstraintOfTypeParameter(<TypeParameter>source);
 
-                    // The constraint may need to be further instantiated with its 'this' type.
-                    constraint = getTypeWithThisArgument(constraint, source);
+                        if (!constraint || constraint.flags & TypeFlags.Any) {
+                            constraint = emptyObjectType;
+                        }
 
-                    // Report constraint errors only if the constraint is not the empty object type
-                    const reportConstraintErrors = reportErrors && constraint !== emptyObjectType;
-                    if (result = isRelatedTo(constraint, target, reportConstraintErrors)) {
-                        errorInfo = saveErrorInfo;
-                        return result;
+                        // The constraint may need to be further instantiated with its 'this' type.
+                        constraint = getTypeWithThisArgument(constraint, source);
+
+                        // Report constraint errors only if the constraint is not the empty object type
+                        const reportConstraintErrors = reportErrors && constraint !== emptyObjectType;
+                        if (result = isRelatedTo(constraint, target, reportConstraintErrors)) {
+                            errorInfo = saveErrorInfo;
+                            return result;
+                        }
                     }
                 }
                 else {

src/compiler/diagnosticMessages.json

@@ -1731,7 +1731,7 @@
         "category": "Error",
         "code": 2535
     },
-    "Type '{0}' is not constrained to 'keyof {1}'.": {
+    "Type '{0}' cannot be used to index type '{1}'.": {
         "category": "Error",
         "code": 2536
     },

src/compiler/types.ts

@@ -2974,8 +2974,6 @@ namespace ts {
         /* @internal */
         resolvedIndexType: IndexType;
         /* @internal */
-        resolvedIndexedAccessTypes: IndexedAccessType[];
-        /* @internal */
         isThisType?: boolean;
     }
 
@@ -2985,7 +2983,7 @@ namespace ts {
 
     export interface IndexedAccessType extends Type {
         objectType: Type;
-        indexType: TypeParameter;
+        indexType: Type;
     }
 
     export const enum SignatureKind {

tests/baselines/reference/mappedTypeRelationships.errors.txt

@@ -0,0 +1,183 @@
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(12,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'.
+  Type 'T' is not assignable to type 'U'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(17,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K]'.
+  Type 'T' is not assignable to type 'U'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(21,5): error TS2536: Type 'keyof U' cannot be used to index type 'T'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(22,12): error TS2536: Type 'keyof U' cannot be used to index type 'T'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(26,5): error TS2536: Type 'K' cannot be used to index type 'T'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(27,12): error TS2536: Type 'K' cannot be used to index type 'T'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(31,5): error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'.
+  Type 'undefined' is not assignable to type 'T[keyof T]'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(36,5): error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'.
+  Type 'undefined' is not assignable to type 'T[K]'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(41,5): error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'.
+  Type 'undefined' is not assignable to type 'T[keyof T]'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(42,5): error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'.
+  Type 'T[keyof T]' is not assignable to type 'U[keyof T]'.
+    Type 'T' is not assignable to type 'U'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(46,5): error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'.
+  Type 'undefined' is not assignable to type 'T[K]'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(47,5): error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'.
+  Type 'T[K]' is not assignable to type 'U[K]'.
+    Type 'T' is not assignable to type 'U'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(52,5): error TS2542: Index signature in type 'Readonly<T>' only permits reading.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(57,5): error TS2542: Index signature in type 'Readonly<T>' only permits reading.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(62,5): error TS2542: Index signature in type 'Readonly<U>' only permits reading.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(67,5): error TS2542: Index signature in type 'Readonly<U>' only permits reading.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(71,5): error TS2322: Type 'Partial<T>' is not assignable to type 'T'.
+tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(76,5): error TS2322: Type 'Partial<T>' is not assignable to type 'T'.
+
+
+==== tests/cases/conformance/types/mapped/mappedTypeRelationships.ts (18 errors) ====
+    
+    function f1<T>(x: T, k: keyof T) {
+        return x[k];
+    }
+    
+    function f2<T, K extends keyof T>(x: T, k: K) {
+        return x[k];
+    }
+    
+    function f3<T, U extends T>(x: T, y: U, k: keyof T) {
+        x[k] = y[k];
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T]'.
+!!! error TS2322:   Type 'T' is not assignable to type 'U'.
+    }
+    
+    function f4<T, U extends T, K extends keyof T>(x: T, y: U, k: K) {
+        x[k] = y[k];
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'T[K]' is not assignable to type 'U[K]'.
+!!! error TS2322:   Type 'T' is not assignable to type 'U'.
+    }
+    
+    function f5<T, U extends T>(x: T, y: U, k: keyof U) {
+        x[k] = y[k];  // Error
+        ~~~~
+!!! error TS2536: Type 'keyof U' cannot be used to index type 'T'.
+        y[k] = x[k];  // Error
+               ~~~~
+!!! error TS2536: Type 'keyof U' cannot be used to index type 'T'.
+    }
+    
+    function f6<T, U extends T, K extends keyof U>(x: T, y: U, k: K) {
+        x[k] = y[k];  // Error
+        ~~~~
+!!! error TS2536: Type 'K' cannot be used to index type 'T'.
+        y[k] = x[k];  // Error
+               ~~~~
+!!! error TS2536: Type 'K' cannot be used to index type 'T'.
+    }
+    
+    function f10<T>(x: T, y: Partial<T>, k: keyof T) {
+        x[k] = y[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'.
+!!! error TS2322:   Type 'undefined' is not assignable to type 'T[keyof T]'.
+        y[k] = x[k];
+    }
+    
+    function f11<T, K extends keyof T>(x: T, y: Partial<T>, k: K) {
+        x[k] = y[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'T[K] | undefined' is not assignable to type 'T[K]'.
+!!! error TS2322:   Type 'undefined' is not assignable to type 'T[K]'.
+        y[k] = x[k];
+    }
+    
+    function f12<T, U extends T>(x: T, y: Partial<U>, k: keyof T) {
+        x[k] = y[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'U[keyof T] | undefined' is not assignable to type 'T[keyof T]'.
+!!! error TS2322:   Type 'undefined' is not assignable to type 'T[keyof T]'.
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'T[keyof T]' is not assignable to type 'U[keyof T] | undefined'.
+!!! error TS2322:   Type 'T[keyof T]' is not assignable to type 'U[keyof T]'.
+!!! error TS2322:     Type 'T' is not assignable to type 'U'.
+    }
+    
+    function f13<T, U extends T, K extends keyof T>(x: T, y: Partial<U>, k: K) {
+        x[k] = y[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'U[K] | undefined' is not assignable to type 'T[K]'.
+!!! error TS2322:   Type 'undefined' is not assignable to type 'T[K]'.
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2322: Type 'T[K]' is not assignable to type 'U[K] | undefined'.
+!!! error TS2322:   Type 'T[K]' is not assignable to type 'U[K]'.
+!!! error TS2322:     Type 'T' is not assignable to type 'U'.
+    }
+    
+    function f20<T>(x: T, y: Readonly<T>, k: keyof T) {
+        x[k] = y[k];
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2542: Index signature in type 'Readonly<T>' only permits reading.
+    }
+    
+    function f21<T, K extends keyof T>(x: T, y: Readonly<T>, k: K) {
+        x[k] = y[k];
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2542: Index signature in type 'Readonly<T>' only permits reading.
+    }
+    
+    function f22<T, U extends T>(x: T, y: Readonly<U>, k: keyof T) {
+        x[k] = y[k];
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2542: Index signature in type 'Readonly<U>' only permits reading.
+    }
+    
+    function f23<T, U extends T, K extends keyof T>(x: T, y: Readonly<U>, k: K) {
+        x[k] = y[k];
+        y[k] = x[k];  // Error
+        ~~~~
+!!! error TS2542: Index signature in type 'Readonly<U>' only permits reading.
+    }
+    
+    function f30<T>(x: T, y: Partial<T>) {
+        x = y;  // Error
+        ~
+!!! error TS2322: Type 'Partial<T>' is not assignable to type 'T'.
+        y = x;
+    }
+    
+    function f31<T>(x: T, y: Partial<T>) {
+        x = y;  // Error
+        ~
+!!! error TS2322: Type 'Partial<T>' is not assignable to type 'T'.
+        y = x;
+    }
+    
+    function f40<T>(x: T, y: Readonly<T>) {
+        x = y;
+        y = x;
+    }
+    
+    function f41<T>(x: T, y: Readonly<T>) {
+        x = y;
+        y = x;
+    }
+    
+    type Item = {
+        name: string;
+    }
+    
+    type ItemMap = {
+        [x: string]: Item;
+    }
+    
+    function f50<T extends ItemMap>(obj: T, key: keyof T) {
+        let item: Item = obj[key];
+        return obj[key].name;
+    }
+    
+    function f51<T extends ItemMap, K extends keyof T>(obj: T, key: K) {
+        let item: Item = obj[key];
+        return obj[key].name;
+    }

tests/baselines/reference/mappedTypeRelationships.js

@@ -0,0 +1,216 @@
+//// [mappedTypeRelationships.ts]
+
+function f1<T>(x: T, k: keyof T) {
+    return x[k];
+}
+
+function f2<T, K extends keyof T>(x: T, k: K) {
+    return x[k];
+}
+
+function f3<T, U extends T>(x: T, y: U, k: keyof T) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f4<T, U extends T, K extends keyof T>(x: T, y: U, k: K) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f5<T, U extends T>(x: T, y: U, k: keyof U) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f6<T, U extends T, K extends keyof U>(x: T, y: U, k: K) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f10<T>(x: T, y: Partial<T>, k: keyof T) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];
+}
+
+function f11<T, K extends keyof T>(x: T, y: Partial<T>, k: K) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];
+}
+
+function f12<T, U extends T>(x: T, y: Partial<U>, k: keyof T) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f13<T, U extends T, K extends keyof T>(x: T, y: Partial<U>, k: K) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f20<T>(x: T, y: Readonly<T>, k: keyof T) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f21<T, K extends keyof T>(x: T, y: Readonly<T>, k: K) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f22<T, U extends T>(x: T, y: Readonly<U>, k: keyof T) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f23<T, U extends T, K extends keyof T>(x: T, y: Readonly<U>, k: K) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f30<T>(x: T, y: Partial<T>) {
+    x = y;  // Error
+    y = x;
+}
+
+function f31<T>(x: T, y: Partial<T>) {
+    x = y;  // Error
+    y = x;
+}
+
+function f40<T>(x: T, y: Readonly<T>) {
+    x = y;
+    y = x;
+}
+
+function f41<T>(x: T, y: Readonly<T>) {
+    x = y;
+    y = x;
+}
+
+type Item = {
+    name: string;
+}
+
+type ItemMap = {
+    [x: string]: Item;
+}
+
+function f50<T extends ItemMap>(obj: T, key: keyof T) {
+    let item: Item = obj[key];
+    return obj[key].name;
+}
+
+function f51<T extends ItemMap, K extends keyof T>(obj: T, key: K) {
+    let item: Item = obj[key];
+    return obj[key].name;
+}
+
+//// [mappedTypeRelationships.js]
+function f1(x, k) {
+    return x[k];
+}
+function f2(x, k) {
+    return x[k];
+}
+function f3(x, y, k) {
+    x[k] = y[k];
+    y[k] = x[k]; // Error
+}
+function f4(x, y, k) {
+    x[k] = y[k];
+    y[k] = x[k]; // Error
+}
+function f5(x, y, k) {
+    x[k] = y[k]; // Error
+    y[k] = x[k]; // Error
+}
+function f6(x, y, k) {
+    x[k] = y[k]; // Error
+    y[k] = x[k]; // Error
+}
+function f10(x, y, k) {
+    x[k] = y[k]; // Error
+    y[k] = x[k];
+}
+function f11(x, y, k) {
+    x[k] = y[k]; // Error
+    y[k] = x[k];
+}
+function f12(x, y, k) {
+    x[k] = y[k]; // Error
+    y[k] = x[k]; // Error
+}
+function f13(x, y, k) {
+    x[k] = y[k]; // Error
+    y[k] = x[k]; // Error
+}
+function f20(x, y, k) {
+    x[k] = y[k];
+    y[k] = x[k]; // Error
+}
+function f21(x, y, k) {
+    x[k] = y[k];
+    y[k] = x[k]; // Error
+}
+function f22(x, y, k) {
+    x[k] = y[k];
+    y[k] = x[k]; // Error
+}
+function f23(x, y, k) {
+    x[k] = y[k];
+    y[k] = x[k]; // Error
+}
+function f30(x, y) {
+    x = y; // Error
+    y = x;
+}
+function f31(x, y) {
+    x = y; // Error
+    y = x;
+}
+function f40(x, y) {
+    x = y;
+    y = x;
+}
+function f41(x, y) {
+    x = y;
+    y = x;
+}
+function f50(obj, key) {
+    var item = obj[key];
+    return obj[key].name;
+}
+function f51(obj, key) {
+    var item = obj[key];
+    return obj[key].name;
+}
+
+
+//// [mappedTypeRelationships.d.ts]
+declare function f1<T>(x: T, k: keyof T): T[keyof T];
+declare function f2<T, K extends keyof T>(x: T, k: K): T[K];
+declare function f3<T, U extends T>(x: T, y: U, k: keyof T): void;
+declare function f4<T, U extends T, K extends keyof T>(x: T, y: U, k: K): void;
+declare function f5<T, U extends T>(x: T, y: U, k: keyof U): void;
+declare function f6<T, U extends T, K extends keyof U>(x: T, y: U, k: K): void;
+declare function f10<T>(x: T, y: Partial<T>, k: keyof T): void;
+declare function f11<T, K extends keyof T>(x: T, y: Partial<T>, k: K): void;
+declare function f12<T, U extends T>(x: T, y: Partial<U>, k: keyof T): void;
+declare function f13<T, U extends T, K extends keyof T>(x: T, y: Partial<U>, k: K): void;
+declare function f20<T>(x: T, y: Readonly<T>, k: keyof T): void;
+declare function f21<T, K extends keyof T>(x: T, y: Readonly<T>, k: K): void;
+declare function f22<T, U extends T>(x: T, y: Readonly<U>, k: keyof T): void;
+declare function f23<T, U extends T, K extends keyof T>(x: T, y: Readonly<U>, k: K): void;
+declare function f30<T>(x: T, y: Partial<T>): void;
+declare function f31<T>(x: T, y: Partial<T>): void;
+declare function f40<T>(x: T, y: Readonly<T>): void;
+declare function f41<T>(x: T, y: Readonly<T>): void;
+declare type Item = {
+    name: string;
+};
+declare type ItemMap = {
+    [x: string]: Item;
+};
+declare function f50<T extends ItemMap>(obj: T, key: keyof T): string;
+declare function f51<T extends ItemMap, K extends keyof T>(obj: T, key: K): string;

tests/baselines/reference/recursiveMappedTypes.errors.txt

@@ -0,0 +1,26 @@
+tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(4,6): error TS2456: Type alias 'Recurse' circularly references itself.
+tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(8,6): error TS2456: Type alias 'Recurse1' circularly references itself.
+tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,6): error TS2456: Type alias 'Recurse2' circularly references itself.
+
+
+==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (3 errors) ====
+    
+    // Recursive mapped types simply appear empty
+    
+    type Recurse = {
+         ~~~~~~~
+!!! error TS2456: Type alias 'Recurse' circularly references itself.
+        [K in keyof Recurse]: Recurse[K]
+    }
+    
+    type Recurse1 = {
+         ~~~~~~~~
+!!! error TS2456: Type alias 'Recurse1' circularly references itself.
+        [K in keyof Recurse2]: Recurse2[K]
+    }
+    
+    type Recurse2 = {
+         ~~~~~~~~
+!!! error TS2456: Type alias 'Recurse2' circularly references itself.
+        [K in keyof Recurse1]: Recurse1[K]
+    }

tests/cases/conformance/types/mapped/mappedTypeRelationships.ts

@@ -0,0 +1,108 @@
+// @strictNullChecks: true
+// @declaration: true
+
+function f1<T>(x: T, k: keyof T) {
+    return x[k];
+}
+
+function f2<T, K extends keyof T>(x: T, k: K) {
+    return x[k];
+}
+
+function f3<T, U extends T>(x: T, y: U, k: keyof T) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f4<T, U extends T, K extends keyof T>(x: T, y: U, k: K) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f5<T, U extends T>(x: T, y: U, k: keyof U) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f6<T, U extends T, K extends keyof U>(x: T, y: U, k: K) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f10<T>(x: T, y: Partial<T>, k: keyof T) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];
+}
+
+function f11<T, K extends keyof T>(x: T, y: Partial<T>, k: K) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];
+}
+
+function f12<T, U extends T>(x: T, y: Partial<U>, k: keyof T) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f13<T, U extends T, K extends keyof T>(x: T, y: Partial<U>, k: K) {
+    x[k] = y[k];  // Error
+    y[k] = x[k];  // Error
+}
+
+function f20<T>(x: T, y: Readonly<T>, k: keyof T) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f21<T, K extends keyof T>(x: T, y: Readonly<T>, k: K) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f22<T, U extends T>(x: T, y: Readonly<U>, k: keyof T) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f23<T, U extends T, K extends keyof T>(x: T, y: Readonly<U>, k: K) {
+    x[k] = y[k];
+    y[k] = x[k];  // Error
+}
+
+function f30<T>(x: T, y: Partial<T>) {
+    x = y;  // Error
+    y = x;
+}
+
+function f31<T>(x: T, y: Partial<T>) {
+    x = y;  // Error
+    y = x;
+}
+
+function f40<T>(x: T, y: Readonly<T>) {
+    x = y;
+    y = x;
+}
+
+function f41<T>(x: T, y: Readonly<T>) {
+    x = y;
+    y = x;
+}
+
+type Item = {
+    name: string;
+}
+
+type ItemMap = {
+    [x: string]: Item;
+}
+
+function f50<T extends ItemMap>(obj: T, key: keyof T) {
+    let item: Item = obj[key];
+    return obj[key].name;
+}
+
+function f51<T extends ItemMap, K extends keyof T>(obj: T, key: K) {
+    let item: Item = obj[key];
+    return obj[key].name;
+}