Merge pull request microsoft#22707 from Microsoft/fixIndexedAccessInConditionalType

ahejlsberg · web-flow · commit e5f6ed0b6077 · 2018-03-21T15:18:39.000-07:00
Fix indexed access in conditional type
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3040,7 +3040,7 @@ namespace ts {
                     return createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
                 }
                 if (type.flags & TypeFlags.Substitution) {
-                    return typeToTypeNodeHelper((<SubstitutionType>type).typeParameter, context);
+                    return typeToTypeNodeHelper((<SubstitutionType>type).typeVariable, context);
                 }
 
                 Debug.fail("Should be unreachable.");
@@ -7305,7 +7305,7 @@ namespace ts {
             const res = tryGetDeclaredTypeOfSymbol(symbol);
             if (res) {
                 return checkNoTypeArguments(node, symbol) ?
-                    res.flags & TypeFlags.TypeParameter ? getConstrainedTypeParameter(<TypeParameter>res, node) : res :
+                    res.flags & TypeFlags.TypeParameter ? getConstrainedTypeVariable(<TypeParameter>res, node) : res :
                     unknownType;
             }
 
@@ -7344,25 +7344,36 @@ namespace ts {
             }
         }
 
-        function getSubstitutionType(typeParameter: TypeParameter, substitute: Type) {
+        function getSubstitutionType(typeVariable: TypeVariable, substitute: Type) {
             const result = <SubstitutionType>createType(TypeFlags.Substitution);
-            result.typeParameter = typeParameter;
+            result.typeVariable = typeVariable;
             result.substitute = substitute;
             return result;
         }
 
-        function getConstrainedTypeParameter(typeParameter: TypeParameter, node: Node) {
+        function isUnaryTupleTypeNode(node: TypeNode) {
+            return node.kind === SyntaxKind.TupleType && (<TupleTypeNode>node).elementTypes.length === 1;
+        }
+
+        function getImpliedConstraint(typeVariable: TypeVariable, checkNode: TypeNode, extendsNode: TypeNode): Type {
+            return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(typeVariable, (<TupleTypeNode>checkNode).elementTypes[0], (<TupleTypeNode>extendsNode).elementTypes[0]) :
+                getActualTypeVariable(getTypeFromTypeNode(checkNode)) === typeVariable ? getTypeFromTypeNode(extendsNode) :
+                undefined;
+        }
+
+        function getConstrainedTypeVariable(typeVariable: TypeVariable, node: Node) {
             let constraints: Type[];
             while (isPartOfTypeNode(node)) {
                 const parent = node.parent;
                 if (parent.kind === SyntaxKind.ConditionalType && node === (<ConditionalTypeNode>parent).trueType) {
-                    if (getTypeFromTypeNode((<ConditionalTypeNode>parent).checkType) === typeParameter) {
-                        constraints = append(constraints, getTypeFromTypeNode((<ConditionalTypeNode>parent).extendsType));
+                    const constraint = getImpliedConstraint(typeVariable, (<ConditionalTypeNode>parent).checkType, (<ConditionalTypeNode>parent).extendsType);
+                    if (constraint) {
+                        constraints = append(constraints, constraint);
                     }
                 }
                 node = parent;
             }
-            return constraints ? getSubstitutionType(typeParameter, getIntersectionType(append(constraints, typeParameter))) : typeParameter;
+            return constraints ? getSubstitutionType(typeVariable, getIntersectionType(append(constraints, typeVariable))) : typeVariable;
         }
 
         function isJSDocTypeReference(node: TypeReferenceType): node is TypeReferenceNode {
@@ -8258,7 +8269,13 @@ namespace ts {
         function getTypeFromIndexedAccessTypeNode(node: IndexedAccessTypeNode) {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = getIndexedAccessType(getTypeFromTypeNode(node.objectType), getTypeFromTypeNode(node.indexType), node);
+                const objectType = getTypeFromTypeNode(node.objectType);
+                const indexType = getTypeFromTypeNode(node.indexType);
+                const resolved = getIndexedAccessType(objectType, indexType, node);
+                links.resolvedType = resolved.flags & TypeFlags.IndexedAccess &&
+                    (<IndexedAccessType>resolved).objectType === objectType &&
+                    (<IndexedAccessType>resolved).indexType === indexType ?
+                    getConstrainedTypeVariable(<IndexedAccessType>resolved, node) : resolved;
             }
             return links.resolvedType;
         }
@@ -8278,8 +8295,8 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function getActualTypeParameter(type: Type) {
-            return type.flags & TypeFlags.Substitution ? (<SubstitutionType>type).typeParameter : type;
+        function getActualTypeVariable(type: Type) {
+            return type.flags & TypeFlags.Substitution ? (<SubstitutionType>type).typeVariable : type;
         }
 
         function getConditionalType(root: ConditionalRoot, mapper: TypeMapper): Type {
@@ -8323,7 +8340,7 @@ namespace ts {
                 }
             }
             // Return a deferred type for a check that is neither definitely true nor definitely false
-            const erasedCheckType = getActualTypeParameter(checkType);
+            const erasedCheckType = getActualTypeVariable(checkType);
             const result = <ConditionalType>createType(TypeFlags.Conditional);
             result.root = root;
             result.checkType = erasedCheckType;
@@ -9043,7 +9060,7 @@ namespace ts {
                     return getConditionalTypeInstantiation(<ConditionalType>type, combineTypeMappers((<ConditionalType>type).mapper, mapper));
                 }
                 if (type.flags & TypeFlags.Substitution) {
-                    return mapper((<SubstitutionType>type).typeParameter);
+                    return instantiateType((<SubstitutionType>type).typeVariable, mapper);
                 }
             }
             return type;
@@ -9650,10 +9667,10 @@ namespace ts {
                     target = (<LiteralType>target).regularType;
                 }
                 if (source.flags & TypeFlags.Substitution) {
-                    source = relation === definitelyAssignableRelation ? (<SubstitutionType>source).typeParameter : (<SubstitutionType>source).substitute;
+                    source = relation === definitelyAssignableRelation ? (<SubstitutionType>source).typeVariable : (<SubstitutionType>source).substitute;
                 }
                 if (target.flags & TypeFlags.Substitution) {
-                    target = (<SubstitutionType>target).typeParameter;
+                    target = (<SubstitutionType>target).typeVariable;
                 }
 
                 // both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -3845,6 +3845,8 @@ namespace ts {
         constraint?: Type;
     }
 
+    export type TypeVariable = TypeParameter | IndexedAccessType;
+
     // keyof T types (TypeFlags.Index)
     export interface IndexType extends InstantiableType {
         type: InstantiableType | UnionOrIntersectionType;
@@ -3876,14 +3878,14 @@ namespace ts {
     }
 
     // Type parameter substitution (TypeFlags.Substitution)
-    // Substitution types are created for type parameter references that occur in the true branch
-    // of a conditional type. For example, in 'T extends string ? Foo<T> : Bar<T>', the reference to
-    // T in Foo<T> is resolved as a substitution type that substitutes 'string & T' for T. Thus, if
-    // Foo has a 'string' constraint on its type parameter, T will satisfy it. Substitution types
-    // disappear upon instantiation (just like type parameters).
+    // Substitution types are created for type parameters or indexed access types that occur in the
+    // true branch of a conditional type. For example, in 'T extends string ? Foo<T> : Bar<T>', the
+    // reference to T in Foo<T> is resolved as a substitution type that substitutes 'string & T' for T.
+    // Thus, if Foo has a 'string' constraint on its type parameter, T will satisfy it. Substitution
+    // types disappear upon instantiation (just like type parameters).
     export interface SubstitutionType extends InstantiableType {
-        typeParameter: TypeParameter;  // Target type parameter
-        substitute: Type;              // Type to substitute for type parameter
+        typeVariable: TypeVariable;  // Target type variable
+        substitute: Type;            // Type to substitute for type parameter
     }
 
     export const enum SignatureKind {
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2192,6 +2192,7 @@ declare namespace ts {
         indexType: Type;
         constraint?: Type;
     }
+    type TypeVariable = TypeParameter | IndexedAccessType;
     interface IndexType extends InstantiableType {
         type: InstantiableType | UnionOrIntersectionType;
     }
@@ -2216,7 +2217,7 @@ declare namespace ts {
         resolvedFalseType?: Type;
     }
     interface SubstitutionType extends InstantiableType {
-        typeParameter: TypeParameter;
+        typeVariable: TypeVariable;
         substitute: Type;
     }
     enum SignatureKind {
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -2192,6 +2192,7 @@ declare namespace ts {
         indexType: Type;
         constraint?: Type;
     }
+    type TypeVariable = TypeParameter | IndexedAccessType;
     interface IndexType extends InstantiableType {
         type: InstantiableType | UnionOrIntersectionType;
     }
@@ -2216,7 +2217,7 @@ declare namespace ts {
         resolvedFalseType?: Type;
     }
     interface SubstitutionType extends InstantiableType {
-        typeParameter: TypeParameter;
+        typeVariable: TypeVariable;
         substitute: Type;
     }
     enum SignatureKind {
diff --git a/tests/baselines/reference/conditionalTypes1.errors.txt b/tests/baselines/reference/conditionalTypes1.errors.txt
@@ -64,8 +64,8 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(159,5): error TS2
 tests/cases/conformance/types/conditional/conditionalTypes1.ts(160,5): error TS2322: Type 'T' is not assignable to type 'ZeroOf<T>'.
   Type 'string | number' is not assignable to type 'ZeroOf<T>'.
     Type 'string' is not assignable to type 'ZeroOf<T>'.
-tests/cases/conformance/types/conditional/conditionalTypes1.ts(250,9): error TS2403: Subsequent variable declarations must have the same type.  Variable 'z' must be of type 'T1', but here has type 'Foo<T & U>'.
-tests/cases/conformance/types/conditional/conditionalTypes1.ts(275,43): error TS2322: Type 'T95<U>' is not assignable to type 'T94<U>'.
+tests/cases/conformance/types/conditional/conditionalTypes1.ts(255,9): error TS2403: Subsequent variable declarations must have the same type.  Variable 'z' must be of type 'T1', but here has type 'Foo<T & U>'.
+tests/cases/conformance/types/conditional/conditionalTypes1.ts(280,43): error TS2322: Type 'T95<U>' is not assignable to type 'T94<U>'.
   Type 'boolean' is not assignable to type 'true'.
 
 
@@ -318,6 +318,11 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(275,43): error TS
 !!! error TS2322:     Type 'string' is not assignable to type 'ZeroOf<T>'.
     }
     
+    type T35<T extends { a: string, b: number }> = T[];
+    type T36<T> = T extends { a: string } ? T extends { b: number } ? T35<T> : never : never;
+    type T37<T> = T extends { b: number } ? T extends { a: string } ? T35<T> : never : never;
+    type T38<T> = [T] extends [{ a: string }] ? [T] extends [{ b: number }] ? T35<T> : never : never;
+    
     type Extends<T, U> = T extends U ? true : false;
     type If<C extends boolean, T, F> = C extends true ? T : F;
     type Not<C extends boolean> = If<C, false, true>;
@@ -477,4 +482,15 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(275,43): error TS
     
     type Test1 = NonFooKeys1<{foo: 1, bar: 2, baz: 3}>;  // "bar" | "baz"
     type Test2 = NonFooKeys2<{foo: 1, bar: 2, baz: 3}>;  // "bar" | "baz"
+    
+    // Repro from #21729
+    
+    interface Foo2 { foo: string; }
+    interface Bar2 { bar: string; }
+    type FooBar = Foo2 | Bar2;
+    declare interface ExtractFooBar<FB extends FooBar> { }
+    
+    type Extracted<Struct> = {
+        [K in keyof Struct]: Struct[K] extends FooBar ? ExtractFooBar<Struct[K]> : Struct[K];
+    }
     
diff --git a/tests/baselines/reference/conditionalTypes1.js b/tests/baselines/reference/conditionalTypes1.js
@@ -161,6 +161,11 @@ function f21<T extends number | string>(x: T, y: ZeroOf<T>) {
     y = x;  // Error
 }
 
+type T35<T extends { a: string, b: number }> = T[];
+type T36<T> = T extends { a: string } ? T extends { b: number } ? T35<T> : never : never;
+type T37<T> = T extends { b: number } ? T extends { a: string } ? T35<T> : never : never;
+type T38<T> = [T] extends [{ a: string }] ? [T] extends [{ b: number }] ? T35<T> : never : never;
+
 type Extends<T, U> = T extends U ? true : false;
 type If<C extends boolean, T, F> = C extends true ? T : F;
 type Not<C extends boolean> = If<C, false, true>;
@@ -315,6 +320,17 @@ type NonFooKeys2<T extends object> = Exclude<keyof T, 'foo'>;
 
 type Test1 = NonFooKeys1<{foo: 1, bar: 2, baz: 3}>;  // "bar" | "baz"
 type Test2 = NonFooKeys2<{foo: 1, bar: 2, baz: 3}>;  // "bar" | "baz"
+
+// Repro from #21729
+
+interface Foo2 { foo: string; }
+interface Bar2 { bar: string; }
+type FooBar = Foo2 | Bar2;
+declare interface ExtractFooBar<FB extends FooBar> { }
+
+type Extracted<Struct> = {
+    [K in keyof Struct]: Struct[K] extends FooBar ? ExtractFooBar<Struct[K]> : Struct[K];
+}
 
 
 //// [conditionalTypes1.js]
@@ -517,6 +533,25 @@ declare type ZeroOf<T extends number | string | boolean> = T extends number ? 0
 declare function zeroOf<T extends number | string | boolean>(value: T): ZeroOf<T>;
 declare function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T): void;
 declare function f21<T extends number | string>(x: T, y: ZeroOf<T>): void;
+declare type T35<T extends {
+    a: string;
+    b: number;
+}> = T[];
+declare type T36<T> = T extends {
+    a: string;
+} ? T extends {
+    b: number;
+} ? T35<T> : never : never;
+declare type T37<T> = T extends {
+    b: number;
+} ? T extends {
+    a: string;
+} ? T35<T> : never : never;
+declare type T38<T> = [T] extends [{
+    a: string;
+}] ? [T] extends [{
+    b: number;
+}] ? T35<T> : never : never;
 declare type Extends<T, U> = T extends U ? true : false;
 declare type If<C extends boolean, T, F> = C extends true ? T : F;
 declare type Not<C extends boolean> = If<C, false, true>;
@@ -624,3 +659,15 @@ declare type Test2 = NonFooKeys2<{
     bar: 2;
     baz: 3;
 }>;
+interface Foo2 {
+    foo: string;
+}
+interface Bar2 {
+    bar: string;
+}
+declare type FooBar = Foo2 | Bar2;
+declare interface ExtractFooBar<FB extends FooBar> {
+}
+declare type Extracted<Struct> = {
+    [K in keyof Struct]: Struct[K] extends FooBar ? ExtractFooBar<Struct[K]> : Struct[K];
+};
diff --git a/tests/baselines/reference/conditionalTypes1.symbols b/tests/baselines/reference/conditionalTypes1.symbols
diff --git a/tests/baselines/reference/conditionalTypes1.types b/tests/baselines/reference/conditionalTypes1.types
diff --git a/tests/cases/conformance/types/conditional/conditionalTypes1.ts b/tests/cases/conformance/types/conditional/conditionalTypes1.ts

Original file line number	Diff line number	Diff line change
`@@ -3040,7 +3040,7 @@ namespace ts {`
`3040`	`3040`	`return createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);`
`3041`	`3041`	`}`
`3042`	`3042`	`if (type.flags & TypeFlags.Substitution) {`
`3043`		`- return typeToTypeNodeHelper((<SubstitutionType>type).typeParameter, context);`
	`3043`	`+ return typeToTypeNodeHelper((<SubstitutionType>type).typeVariable, context);`
`3044`	`3044`	`}`
`3045`	`3045`
`3046`	`3046`	`Debug.fail("Should be unreachable.");`
`@@ -7305,7 +7305,7 @@ namespace ts {`
`7305`	`7305`	`const res = tryGetDeclaredTypeOfSymbol(symbol);`
`7306`	`7306`	`if (res) {`
`7307`	`7307`	`return checkNoTypeArguments(node, symbol) ?`
`7308`		`- res.flags & TypeFlags.TypeParameter ? getConstrainedTypeParameter(<TypeParameter>res, node) : res :`
	`7308`	`+ res.flags & TypeFlags.TypeParameter ? getConstrainedTypeVariable(<TypeParameter>res, node) : res :`
`7309`	`7309`	`unknownType;`
`7310`	`7310`	`}`
`7311`	`7311`
`@@ -7344,25 +7344,36 @@ namespace ts {`
`7344`	`7344`	`}`
`7345`	`7345`	`}`
`7346`	`7346`
`7347`		`- function getSubstitutionType(typeParameter: TypeParameter, substitute: Type) {`
	`7347`	`+ function getSubstitutionType(typeVariable: TypeVariable, substitute: Type) {`
`7348`	`7348`	`const result = <SubstitutionType>createType(TypeFlags.Substitution);`
`7349`		`- result.typeParameter = typeParameter;`
	`7349`	`+ result.typeVariable = typeVariable;`
`7350`	`7350`	`result.substitute = substitute;`
`7351`	`7351`	`return result;`
`7352`	`7352`	`}`
`7353`	`7353`
`7354`		`- function getConstrainedTypeParameter(typeParameter: TypeParameter, node: Node) {`
	`7354`	`+ function isUnaryTupleTypeNode(node: TypeNode) {`
	`7355`	`+ return node.kind === SyntaxKind.TupleType && (<TupleTypeNode>node).elementTypes.length === 1;`
	`7356`	`+ }`
	`7357`	`+`
	`7358`	`+ function getImpliedConstraint(typeVariable: TypeVariable, checkNode: TypeNode, extendsNode: TypeNode): Type {`
	`7359`	`+ return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(typeVariable, (<TupleTypeNode>checkNode).elementTypes[0], (<TupleTypeNode>extendsNode).elementTypes[0]) :`
	`7360`	`+ getActualTypeVariable(getTypeFromTypeNode(checkNode)) === typeVariable ? getTypeFromTypeNode(extendsNode) :`
	`7361`	`+ undefined;`
	`7362`	`+ }`
	`7363`	`+`
	`7364`	`+ function getConstrainedTypeVariable(typeVariable: TypeVariable, node: Node) {`
`7355`	`7365`	`let constraints: Type[];`
`7356`	`7366`	`while (isPartOfTypeNode(node)) {`
`7357`	`7367`	`const parent = node.parent;`
`7358`	`7368`	`if (parent.kind === SyntaxKind.ConditionalType && node === (<ConditionalTypeNode>parent).trueType) {`
`7359`		`- if (getTypeFromTypeNode((<ConditionalTypeNode>parent).checkType) === typeParameter) {`
`7360`		`- constraints = append(constraints, getTypeFromTypeNode((<ConditionalTypeNode>parent).extendsType));`
	`7369`	`+ const constraint = getImpliedConstraint(typeVariable, (<ConditionalTypeNode>parent).checkType, (<ConditionalTypeNode>parent).extendsType);`
	`7370`	`+ if (constraint) {`
	`7371`	`+ constraints = append(constraints, constraint);`
`7361`	`7372`	`}`
`7362`	`7373`	`}`
`7363`	`7374`	`node = parent;`
`7364`	`7375`	`}`
`7365`		`- return constraints ? getSubstitutionType(typeParameter, getIntersectionType(append(constraints, typeParameter))) : typeParameter;`
	`7376`	`+ return constraints ? getSubstitutionType(typeVariable, getIntersectionType(append(constraints, typeVariable))) : typeVariable;`
`7366`	`7377`	`}`
`7367`	`7378`
`7368`	`7379`	`function isJSDocTypeReference(node: TypeReferenceType): node is TypeReferenceNode {`
`@@ -8258,7 +8269,13 @@ namespace ts {`
`8258`	`8269`	`function getTypeFromIndexedAccessTypeNode(node: IndexedAccessTypeNode) {`
`8259`	`8270`	`const links = getNodeLinks(node);`
`8260`	`8271`	`if (!links.resolvedType) {`
`8261`		`- links.resolvedType = getIndexedAccessType(getTypeFromTypeNode(node.objectType), getTypeFromTypeNode(node.indexType), node);`
	`8272`	`+ const objectType = getTypeFromTypeNode(node.objectType);`
	`8273`	`+ const indexType = getTypeFromTypeNode(node.indexType);`
	`8274`	`+ const resolved = getIndexedAccessType(objectType, indexType, node);`
	`8275`	`+ links.resolvedType = resolved.flags & TypeFlags.IndexedAccess &&`
	`8276`	`+ (<IndexedAccessType>resolved).objectType === objectType &&`
	`8277`	`+ (<IndexedAccessType>resolved).indexType === indexType ?`
	`8278`	`+ getConstrainedTypeVariable(<IndexedAccessType>resolved, node) : resolved;`
`8262`	`8279`	`}`
`8263`	`8280`	`return links.resolvedType;`
`8264`	`8281`	`}`
`@@ -8278,8 +8295,8 @@ namespace ts {`
`8278`	`8295`	`return links.resolvedType;`
`8279`	`8296`	`}`
`8280`	`8297`
`8281`		`- function getActualTypeParameter(type: Type) {`
`8282`		`- return type.flags & TypeFlags.Substitution ? (<SubstitutionType>type).typeParameter : type;`
	`8298`	`+ function getActualTypeVariable(type: Type) {`
	`8299`	`+ return type.flags & TypeFlags.Substitution ? (<SubstitutionType>type).typeVariable : type;`
`8283`	`8300`	`}`
`8284`	`8301`
`8285`	`8302`	`function getConditionalType(root: ConditionalRoot, mapper: TypeMapper): Type {`
`@@ -8323,7 +8340,7 @@ namespace ts {`
`8323`	`8340`	`}`
`8324`	`8341`	`}`
`8325`	`8342`	`// Return a deferred type for a check that is neither definitely true nor definitely false`
`8326`		`- const erasedCheckType = getActualTypeParameter(checkType);`
	`8343`	`+ const erasedCheckType = getActualTypeVariable(checkType);`
`8327`	`8344`	`const result = <ConditionalType>createType(TypeFlags.Conditional);`
`8328`	`8345`	`result.root = root;`
`8329`	`8346`	`result.checkType = erasedCheckType;`
`@@ -9043,7 +9060,7 @@ namespace ts {`
`9043`	`9060`	`return getConditionalTypeInstantiation(<ConditionalType>type, combineTypeMappers((<ConditionalType>type).mapper, mapper));`
`9044`	`9061`	`}`
`9045`	`9062`	`if (type.flags & TypeFlags.Substitution) {`
`9046`		`- return mapper((<SubstitutionType>type).typeParameter);`
	`9063`	`+ return instantiateType((<SubstitutionType>type).typeVariable, mapper);`
`9047`	`9064`	`}`
`9048`	`9065`	`}`
`9049`	`9066`	`return type;`
`@@ -9650,10 +9667,10 @@ namespace ts {`
`9650`	`9667`	`target = (<LiteralType>target).regularType;`
`9651`	`9668`	`}`
`9652`	`9669`	`if (source.flags & TypeFlags.Substitution) {`
`9653`		`- source = relation === definitelyAssignableRelation ? (<SubstitutionType>source).typeParameter : (<SubstitutionType>source).substitute;`
	`9670`	`+ source = relation === definitelyAssignableRelation ? (<SubstitutionType>source).typeVariable : (<SubstitutionType>source).substitute;`
`9654`	`9671`	`}`
`9655`	`9672`	`if (target.flags & TypeFlags.Substitution) {`
`9656`		`- target = (<SubstitutionType>target).typeParameter;`
	`9673`	`+ target = (<SubstitutionType>target).typeVariable;`
`9657`	`9674`	`}`
`9658`	`9675`
`9659`	`9676`	`// both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases`
Original file line number	Diff line number	Diff line change
`@@ -2192,6 +2192,7 @@ declare namespace ts {`
`2192`	`2192`	`indexType: Type;`
`2193`	`2193`	`constraint?: Type;`
`2194`	`2194`	`}`
	`2195`	`+ type TypeVariable = TypeParameter \| IndexedAccessType;`
`2195`	`2196`	`interface IndexType extends InstantiableType {`
`2196`	`2197`	`type: InstantiableType \| UnionOrIntersectionType;`
`2197`	`2198`	`}`
`@@ -2216,7 +2217,7 @@ declare namespace ts {`
`2216`	`2217`	`resolvedFalseType?: Type;`
`2217`	`2218`	`}`
`2218`	`2219`	`interface SubstitutionType extends InstantiableType {`
`2219`		`- typeParameter: TypeParameter;`
	`2220`	`+ typeVariable: TypeVariable;`
`2220`	`2221`	`substitute: Type;`
`2221`	`2222`	`}`
`2222`	`2223`	`enum SignatureKind {`