Fix non-thenable check for IndexedAccess types

src/compiler/checker.ts

@@ -3074,10 +3074,6 @@ namespace ts {
             return type && (type.flags & TypeFlags.Any) !== 0;
         }
 
-        function isTypeNever(type: Type) {
-            return type && (type.flags & TypeFlags.Never) !== 0;
-        }
-
         // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
         // assigned by contextual typing.
         function getTypeForBindingElementParent(node: VariableLikeDeclaration) {
@@ -16285,9 +16281,10 @@ namespace ts {
             }
         }
 
-        function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage) {
+        function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage): Type {
             type = getWidenedType(type);
-            if (!isTypeAny(type) && !isTypeNever(type) && isTypeAssignableTo(type, getGlobalThenableType())) {
+            const apparentType = getApparentType(type);
+            if ((apparentType.flags & (TypeFlags.Any | TypeFlags.Never)) === 0 && isTypeAssignableTo(type, getGlobalThenableType())) {
                 if (location) {
                     if (!message) {
                         message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member;

tests/baselines/reference/asyncFunctionReturnType.js

@@ -8,7 +8,72 @@ async function fAsyncExplicit(): Promise<[number, boolean]> {
     // This is contextually typed as a tuple.
     return [1, true];
 }
-
+
+// https://github.com/Microsoft/TypeScript/issues/13128
+interface Obj {
+    stringProp: string;
+    anyProp: any;
+}
+
+async function fIndexedTypeForStringProp(obj: Obj): Promise<Obj["stringProp"]> {
+    return obj.stringProp;
+}
+
+async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["stringProp"]> {
+    return Promise.resolve(obj.stringProp);
+}
+
+async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj["stringProp"]> {
+    return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
+}
+
+async function fIndexedTypeForAnyProp(obj: Obj): Promise<Obj["anyProp"]> {
+    return obj.anyProp;
+}
+
+async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]> {
+    return Promise.resolve(obj.anyProp);
+}
+
+async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]> {
+    return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
+}
+
+async function fGenericIndexedTypeForStringProp<TObj extends Obj>(obj: TObj): Promise<TObj["stringProp"]> {
+    return obj.stringProp;
+}
+
+async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj: TObj): Promise<TObj["stringProp"]> {
+    return Promise.resolve(obj.stringProp);
+}
+
+async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Obj>(obj: TObj): Promise<TObj["stringProp"]> {
+    return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
+}
+
+async function fGenericIndexedTypeForAnyProp<TObj extends Obj>(obj: TObj): Promise<TObj["anyProp"]> {
+    return obj.anyProp;
+}
+
+async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TObj): Promise<TObj["anyProp"]> {
+    return Promise.resolve(obj.anyProp);
+}
+
+async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(obj: TObj): Promise<TObj["anyProp"]> {
+    return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
+}
+
+async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+    return obj[key];
+}
+
+async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+    return Promise.resolve(obj[key]);
+}
+
+async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+    return Promise.resolve<TObj[K]>(obj[key]);
+}
 
 //// [asyncFunctionReturnType.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -31,3 +96,78 @@ function fAsyncExplicit() {
         return [1, true];
     });
 }
+function fIndexedTypeForStringProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return obj.stringProp;
+    });
+}
+function fIndexedTypeForPromiseOfStringProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.stringProp);
+    });
+}
+function fIndexedTypeForExplicitPromiseOfStringProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.stringProp);
+    });
+}
+function fIndexedTypeForAnyProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return obj.anyProp;
+    });
+}
+function fIndexedTypeForPromiseOfAnyProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.anyProp);
+    });
+}
+function fIndexedTypeForExplicitPromiseOfAnyProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.anyProp);
+    });
+}
+function fGenericIndexedTypeForStringProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return obj.stringProp;
+    });
+}
+function fGenericIndexedTypeForPromiseOfStringProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.stringProp);
+    });
+}
+function fGenericIndexedTypeForExplicitPromiseOfStringProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.stringProp);
+    });
+}
+function fGenericIndexedTypeForAnyProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return obj.anyProp;
+    });
+}
+function fGenericIndexedTypeForPromiseOfAnyProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.anyProp);
+    });
+}
+function fGenericIndexedTypeForExplicitPromiseOfAnyProp(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj.anyProp);
+    });
+}
+function fGenericIndexedTypeForKProp(obj, key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return obj[key];
+    });
+}
+function fGenericIndexedTypeForPromiseOfKProp(obj, key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj[key]);
+    });
+}
+function fGenericIndexedTypeForExplicitPromiseOfKProp(obj, key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(obj[key]);
+    });
+}