Port fixes to release2.8

src/compiler/checker.ts

@@ -4083,8 +4083,7 @@ namespace ts {
                     if (strictNullChecks && declaration.flags & NodeFlags.Ambient && isParameterDeclaration(declaration)) {
                         parentType = getNonNullableType(parentType);
                     }
-                    const propType = getTypeOfPropertyOfType(parentType, text);
-                    const declaredType = propType && getConstraintForLocation(propType, declaration.name);
+                    const declaredType = getConstraintForLocation(getTypeOfPropertyOfType(parentType, text), declaration.name);
                     type = declaredType && getFlowTypeOfReference(declaration, declaredType) ||
                         isNumericLiteralName(text) && getIndexTypeOfType(parentType, IndexKind.Number) ||
                         getIndexTypeOfType(parentType, IndexKind.String);
@@ -10227,8 +10226,11 @@ namespace ts {
                 }
                 else if (source.flags & TypeFlags.Conditional) {
                     if (target.flags & TypeFlags.Conditional) {
-                        if (isTypeIdenticalTo((<ConditionalType>source).checkType, (<ConditionalType>target).checkType) &&
-                            isTypeIdenticalTo((<ConditionalType>source).extendsType, (<ConditionalType>target).extendsType)) {
+                        // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if
+                        // one of T1 and T2 is related to the other, U1 and U2 are identical types, X1 is related to X2,
+                        // and Y1 is related to Y2.
+                        if (isTypeIdenticalTo((<ConditionalType>source).extendsType, (<ConditionalType>target).extendsType) &&
+                            (isRelatedTo((<ConditionalType>source).checkType, (<ConditionalType>target).checkType) || isRelatedTo((<ConditionalType>target).checkType, (<ConditionalType>source).checkType))) {
                             if (result = isRelatedTo(getTrueTypeFromConditionalType(<ConditionalType>source), getTrueTypeFromConditionalType(<ConditionalType>target), reportErrors)) {
                                 result &= isRelatedTo(getFalseTypeFromConditionalType(<ConditionalType>source), getFalseTypeFromConditionalType(<ConditionalType>target), reportErrors);
                             }
@@ -12408,7 +12410,7 @@ namespace ts {
 
         function getTypeOfDestructuredProperty(type: Type, name: PropertyName) {
             const text = getTextOfPropertyName(name);
-            return getTypeOfPropertyOfType(type, text) ||
+            return getConstraintForLocation(getTypeOfPropertyOfType(type, text), name) ||
                 isNumericLiteralName(text) && getIndexTypeOfType(type, IndexKind.Number) ||
                 getIndexTypeOfType(type, IndexKind.String) ||
                 unknownType;
@@ -13524,7 +13526,7 @@ namespace ts {
             // and the type of the node includes type variables with constraints that are nullable, we fetch the
             // apparent type of the node *before* performing control flow analysis such that narrowings apply to
             // the constraint type.
-            if (isConstraintPosition(node) && forEachType(type, typeHasNullableConstraint)) {
+            if (type && isConstraintPosition(node) && forEachType(type, typeHasNullableConstraint)) {
                 return mapType(getWidenedType(type), getBaseConstraintOrType);
             }
             return type;

src/services/codefixes/fixAwaitInSyncFunction.ts

@@ -36,6 +36,10 @@ namespace ts.codefix {
     function getNodes(sourceFile: SourceFile, start: number): { insertBefore: Node, returnType: TypeNode | undefined } | undefined {
         const token = getTokenAtPosition(sourceFile, start, /*includeJsDocComment*/ false);
         const containingFunction = getContainingFunction(token);
+        if (!containingFunction) {
+            return;
+        }
+
         let insertBefore: Node | undefined;
         switch (containingFunction.kind) {
             case SyntaxKind.MethodDeclaration:

src/services/codefixes/inferFromUsage.ts

@@ -64,17 +64,21 @@ namespace ts.codefix {
             return undefined;
         }
 
+        const { parent } = token;
         switch (errorCode) {
             // Variable and Property declarations
             case Diagnostics.Member_0_implicitly_has_an_1_type.code:
             case Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code:
-                annotateVariableDeclaration(changes, sourceFile, <PropertyDeclaration | PropertySignature | VariableDeclaration>token.parent, program, cancellationToken);
-                return token.parent as Declaration;
+                if (isVariableDeclaration(parent) || isPropertyDeclaration(parent) || isPropertySignature(parent)) { // handle bad location
+                    annotateVariableDeclaration(changes, sourceFile, parent, program, cancellationToken);
+                    return parent;
+                }
+                return undefined;
 
             case Diagnostics.Variable_0_implicitly_has_an_1_type.code: {
                 const symbol = program.getTypeChecker().getSymbolAtLocation(token);
-                if (symbol && symbol.valueDeclaration) {
-                    annotateVariableDeclaration(changes, sourceFile, <VariableDeclaration>symbol.valueDeclaration, program, cancellationToken);
+                if (symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration)) {
+                    annotateVariableDeclaration(changes, sourceFile, symbol.valueDeclaration, program, cancellationToken);
                     return symbol.valueDeclaration;
                 }
             }
@@ -95,7 +99,7 @@ namespace ts.codefix {
                 // falls through
             case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
                 if (!seenFunctions || addToSeen(seenFunctions, getNodeId(containingFunction))) {
-                    const param = cast(token.parent, isParameter);
+                    const param = cast(parent, isParameter);
                     annotateParameters(changes, param, containingFunction, sourceFile, program, cancellationToken);
                     return param;
                 }

src/services/completions.ts

@@ -1628,7 +1628,7 @@ namespace ts.Completions {
         }
 
         function isFromClassElementDeclaration(node: Node) {
-            return isClassElement(node.parent) && isClassLike(node.parent.parent);
+            return node.parent && isClassElement(node.parent) && isClassLike(node.parent.parent);
         }
 
         function isParameterOfConstructorDeclaration(node: Node) {

tests/baselines/reference/conditionalTypes2.errors.txt

@@ -0,0 +1,90 @@
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(15,5): error TS2322: Type 'Covariant<A>' is not assignable to type 'Covariant<B>'.
+  Type 'A' is not assignable to type 'B'.
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(19,5): error TS2322: Type 'Contravariant<B>' is not assignable to type 'Contravariant<A>'.
+  Type 'A' is not assignable to type 'B'.
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(24,5): error TS2322: Type 'Invariant<B>' is not assignable to type 'Invariant<A>'.
+  Types of property 'foo' are incompatible.
+    Type 'B extends string ? keyof B : B' is not assignable to type 'A extends string ? keyof A : A'.
+      Type 'keyof B' is not assignable to type 'keyof A'.
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(25,5): error TS2322: Type 'Invariant<A>' is not assignable to type 'Invariant<B>'.
+  Types of property 'foo' are incompatible.
+    Type 'A extends string ? keyof A : A' is not assignable to type 'B extends string ? keyof B : B'.
+      Type 'A' is not assignable to type 'B'.
+
+
+==== tests/cases/conformance/types/conditional/conditionalTypes2.ts (4 errors) ====
+    interface Covariant<T> {
+        foo: T extends string ? T : number;
+    }
+
+    interface Contravariant<T> {
+        foo: T extends string ? keyof T : number;
+    }
+
+    interface Invariant<T> {
+        foo: T extends string ? keyof T : T;
+    }
+
+    function f1<A, B extends A>(a: Covariant<A>, b: Covariant<B>) {
+        a = b;
+        b = a;  // Error
+        ~
+!!! error TS2322: Type 'Covariant<A>' is not assignable to type 'Covariant<B>'.
+!!! error TS2322:   Type 'A' is not assignable to type 'B'.
+    }
+
+    function f2<A, B extends A>(a: Contravariant<A>, b: Contravariant<B>) {
+        a = b;  // Error
+        ~
+!!! error TS2322: Type 'Contravariant<B>' is not assignable to type 'Contravariant<A>'.
+!!! error TS2322:   Type 'A' is not assignable to type 'B'.
+        b = a;
+    }
+
+    function f3<A, B extends A>(a: Invariant<A>, b: Invariant<B>) {
+        a = b;  // Error
+        ~
+!!! error TS2322: Type 'Invariant<B>' is not assignable to type 'Invariant<A>'.
+!!! error TS2322:   Types of property 'foo' are incompatible.
+!!! error TS2322:     Type 'B extends string ? keyof B : B' is not assignable to type 'A extends string ? keyof A : A'.
+!!! error TS2322:       Type 'keyof B' is not assignable to type 'keyof A'.
+        b = a;  // Error
+        ~
+!!! error TS2322: Type 'Invariant<A>' is not assignable to type 'Invariant<B>'.
+!!! error TS2322:   Types of property 'foo' are incompatible.
+!!! error TS2322:     Type 'A extends string ? keyof A : A' is not assignable to type 'B extends string ? keyof B : B'.
+!!! error TS2322:       Type 'A' is not assignable to type 'B'.
+    }
+
+    // Repros from #22860
+
+    class Opt<T> {
+        toVector(): Vector<T> {
+            return <any>undefined;
+        }
+    }
+
+    interface Seq<T> {
+        tail(): Opt<Seq<T>>;
+    }
+
+    class Vector<T> implements Seq<T> {
+        tail(): Opt<Vector<T>> {
+            return <any>undefined;
+        }
+        partition2<U extends T>(predicate:(v:T)=>v is U): [Vector<U>,Vector<Exclude<T, U>>];
+        partition2(predicate:(x:T)=>boolean): [Vector<T>,Vector<T>];
+        partition2<U extends T>(predicate:(v:T)=>boolean): [Vector<U>,Vector<any>] {
+            return <any>undefined;
+        }
+    }
+
+    interface A1<T> {
+        bat: B1<A1<T>>;
+    }
+
+    interface B1<T> extends A1<T> {
+        bat: B1<B1<T>>;
+        boom: T extends any ? true : true
+    }
+

tests/baselines/reference/conditionalTypes2.js

@@ -0,0 +1,128 @@
+//// [conditionalTypes2.ts]
+interface Covariant<T> {
+    foo: T extends string ? T : number;
+}
+
+interface Contravariant<T> {
+    foo: T extends string ? keyof T : number;
+}
+
+interface Invariant<T> {
+    foo: T extends string ? keyof T : T;
+}
+
+function f1<A, B extends A>(a: Covariant<A>, b: Covariant<B>) {
+    a = b;
+    b = a;  // Error
+}
+
+function f2<A, B extends A>(a: Contravariant<A>, b: Contravariant<B>) {
+    a = b;  // Error
+    b = a;
+}
+
+function f3<A, B extends A>(a: Invariant<A>, b: Invariant<B>) {
+    a = b;  // Error
+    b = a;  // Error
+}
+
+// Repros from #22860
+
+class Opt<T> {
+    toVector(): Vector<T> {
+        return <any>undefined;
+    }
+}
+
+interface Seq<T> {
+    tail(): Opt<Seq<T>>;
+}
+
+class Vector<T> implements Seq<T> {
+    tail(): Opt<Vector<T>> {
+        return <any>undefined;
+    }
+    partition2<U extends T>(predicate:(v:T)=>v is U): [Vector<U>,Vector<Exclude<T, U>>];
+    partition2(predicate:(x:T)=>boolean): [Vector<T>,Vector<T>];
+    partition2<U extends T>(predicate:(v:T)=>boolean): [Vector<U>,Vector<any>] {
+        return <any>undefined;
+    }
+}
+
+interface A1<T> {
+    bat: B1<A1<T>>;
+}
+
+interface B1<T> extends A1<T> {
+    bat: B1<B1<T>>;
+    boom: T extends any ? true : true
+}
+
+
+//// [conditionalTypes2.js]
+"use strict";
+function f1(a, b) {
+    a = b;
+    b = a; // Error
+}
+function f2(a, b) {
+    a = b; // Error
+    b = a;
+}
+function f3(a, b) {
+    a = b; // Error
+    b = a; // Error
+}
+// Repros from #22860
+var Opt = /** @class */ (function () {
+    function Opt() {
+    }
+    Opt.prototype.toVector = function () {
+        return undefined;
+    };
+    return Opt;
+}());
+var Vector = /** @class */ (function () {
+    function Vector() {
+    }
+    Vector.prototype.tail = function () {
+        return undefined;
+    };
+    Vector.prototype.partition2 = function (predicate) {
+        return undefined;
+    };
+    return Vector;
+}());
+
+
+//// [conditionalTypes2.d.ts]
+interface Covariant<T> {
+    foo: T extends string ? T : number;
+}
+interface Contravariant<T> {
+    foo: T extends string ? keyof T : number;
+}
+interface Invariant<T> {
+    foo: T extends string ? keyof T : T;
+}
+declare function f1<A, B extends A>(a: Covariant<A>, b: Covariant<B>): void;
+declare function f2<A, B extends A>(a: Contravariant<A>, b: Contravariant<B>): void;
+declare function f3<A, B extends A>(a: Invariant<A>, b: Invariant<B>): void;
+declare class Opt<T> {
+    toVector(): Vector<T>;
+}
+interface Seq<T> {
+    tail(): Opt<Seq<T>>;
+}
+declare class Vector<T> implements Seq<T> {
+    tail(): Opt<Vector<T>>;
+    partition2<U extends T>(predicate: (v: T) => v is U): [Vector<U>, Vector<Exclude<T, U>>];
+    partition2(predicate: (x: T) => boolean): [Vector<T>, Vector<T>];
+}
+interface A1<T> {
+    bat: B1<A1<T>>;
+}
+interface B1<T> extends A1<T> {
+    bat: B1<B1<T>>;
+    boom: T extends any ? true : true;
+}