Fix issue #22923: more sofisticated

src/compiler/checker.ts

@@ -16406,9 +16406,15 @@ namespace ts {
                 }
             }
             const suggestion = getSuggestionForNonexistentProperty(propNode, containingType);
+            const subtypeHavingProperty = typeHavingProperty(containingType, propNode.escapedText);
+
             if (suggestion !== undefined) {
                 errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, declarationNameToString(propNode), typeToString(containingType), suggestion);
             }
+            else if (subtypeHavingProperty) {
+                errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_forget_to_await_the_1_as_property_0_exists_on_awaited_2,
+                    declarationNameToString(propNode), typeToString(containingType), typeToString(subtypeHavingProperty));
+            }
             else {
                 errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(propNode), typeToString(containingType));
             }
@@ -16420,6 +16426,14 @@ namespace ts {
             return suggestion && symbolName(suggestion);
         }
 
+        function typeHavingProperty(type: Type, property: __String, errorNode?: Node): Type | undefined {
+            const types: Type[] = (type.flags & TypeFlags.UnionOrIntersection)
+                ? (type as UnionOrIntersectionType).types : [type];
+
+            return find(types.map(t => getPromisedTypeOfPromise(t, errorNode)).filter(t => t !== undefined),
+                t => getPropertyOfType(t, property) !== undefined);
+        }
+
         function getSuggestionForNonexistentSymbol(location: Node, outerName: __String, meaning: SymbolFlags): string {
             Debug.assert(outerName !== undefined, "outername should always be defined");
             const result = resolveNameHelper(location, outerName, meaning, /*nameNotFoundMessage*/ undefined, outerName, /*isUse*/ false, /*excludeGlobals*/ false, (symbols, name, meaning) => {

src/compiler/diagnosticMessages.json

@@ -2000,7 +2000,10 @@
         "category": "Error",
         "code": 2569
     },
-
+    "Property '{0}' does not exist on type '{1}'. Did you forget to await the '{1}' as property '{0}' exists on awaited '{2}'?": {
+        "category": "Error",
+        "code": 2570
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600

tests/baselines/reference/missingPropertyOfPromise.errors.txt

@@ -0,0 +1,10 @@
+tests/cases/compiler/missingPropertyOfPromise.ts(2,7): error TS2570: Property 'toLowerCase' does not exist on type 'Promise<string>'. Did you forget to await the 'Promise<string>' as property 'toLowerCase' exists on awaited 'string'?
+
+
+==== tests/cases/compiler/missingPropertyOfPromise.ts (1 errors) ====
+    function f(x: Promise<string>) {
+        x.toLowerCase();
+          ~~~~~~~~~~~
+!!! error TS2570: Property 'toLowerCase' does not exist on type 'Promise<string>'. Did you forget to await the 'Promise<string>' as property 'toLowerCase' exists on awaited 'string'?
+    }
+

tests/baselines/reference/missingPropertyOfPromise.js

@@ -0,0 +1,10 @@
+//// [missingPropertyOfPromise.ts]
+function f(x: Promise<string>) {
+    x.toLowerCase();
+}
+
+
+//// [missingPropertyOfPromise.js]
+function f(x) {
+    x.toLowerCase();
+}

tests/baselines/reference/missingPropertyOfPromise.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/missingPropertyOfPromise.ts ===
+function f(x: Promise<string>) {
+>f : Symbol(f, Decl(missingPropertyOfPromise.ts, 0, 0))
+>x : Symbol(x, Decl(missingPropertyOfPromise.ts, 0, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
+
+    x.toLowerCase();
+>x : Symbol(x, Decl(missingPropertyOfPromise.ts, 0, 11))
+}
+

tests/baselines/reference/missingPropertyOfPromise.types

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/missingPropertyOfPromise.ts ===
+function f(x: Promise<string>) {
+>f : (x: Promise<string>) => void
+>x : Promise<string>
+>Promise : Promise<T>
+
+    x.toLowerCase();
+>x.toLowerCase() : any
+>x.toLowerCase : any
+>x : Promise<string>
+>toLowerCase : any
+}
+

tests/baselines/reference/missingPropertyOfPromiseIntersection.errors.txt

@@ -0,0 +1,18 @@
+tests/cases/compiler/missingPropertyOfPromiseIntersection.ts(10,7): error TS2570: Property 'method' does not exist on type 'Promise<Foo> & Bar'. Did you forget to await the 'Promise<Foo> & Bar' as property 'method' exists on awaited 'Foo'?
+
+
+==== tests/cases/compiler/missingPropertyOfPromiseIntersection.ts (1 errors) ====
+    interface Foo {
+        method();
+    }
+
+    interface Bar {
+        somethingElse();
+    }
+
+    function f(x: Promise<Foo> & Bar) {
+        x.method();
+          ~~~~~~
+!!! error TS2570: Property 'method' does not exist on type 'Promise<Foo> & Bar'. Did you forget to await the 'Promise<Foo> & Bar' as property 'method' exists on awaited 'Foo'?
+    }
+

tests/baselines/reference/missingPropertyOfPromiseIntersection.js

@@ -0,0 +1,18 @@
+//// [missingPropertyOfPromiseIntersection.ts]
+interface Foo {
+    method();
+}
+
+interface Bar {
+    somethingElse();
+}
+
+function f(x: Promise<Foo> & Bar) {
+    x.method();
+}
+
+
+//// [missingPropertyOfPromiseIntersection.js]
+function f(x) {
+    x.method();
+}

tests/baselines/reference/missingPropertyOfPromiseIntersection.symbols

@@ -0,0 +1,26 @@
+=== tests/cases/compiler/missingPropertyOfPromiseIntersection.ts ===
+interface Foo {
+>Foo : Symbol(Foo, Decl(missingPropertyOfPromiseIntersection.ts, 0, 0))
+
+    method();
+>method : Symbol(Foo.method, Decl(missingPropertyOfPromiseIntersection.ts, 0, 15))
+}
+
+interface Bar {
+>Bar : Symbol(Bar, Decl(missingPropertyOfPromiseIntersection.ts, 2, 1))
+
+    somethingElse();
+>somethingElse : Symbol(Bar.somethingElse, Decl(missingPropertyOfPromiseIntersection.ts, 4, 15))
+}
+
+function f(x: Promise<Foo> & Bar) {
+>f : Symbol(f, Decl(missingPropertyOfPromiseIntersection.ts, 6, 1))
+>x : Symbol(x, Decl(missingPropertyOfPromiseIntersection.ts, 8, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
+>Foo : Symbol(Foo, Decl(missingPropertyOfPromiseIntersection.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(missingPropertyOfPromiseIntersection.ts, 2, 1))
+
+    x.method();
+>x : Symbol(x, Decl(missingPropertyOfPromiseIntersection.ts, 8, 11))
+}
+

tests/baselines/reference/missingPropertyOfPromiseIntersection.types

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/missingPropertyOfPromiseIntersection.ts ===
+interface Foo {
+>Foo : Foo
+
+    method();
+>method : () => any
+}
+
+interface Bar {
+>Bar : Bar
+
+    somethingElse();
+>somethingElse : () => any
+}
+
+function f(x: Promise<Foo> & Bar) {
+>f : (x: Promise<Foo> & Bar) => void
+>x : Promise<Foo> & Bar
+>Promise : Promise<T>
+>Foo : Foo
+>Bar : Bar
+
+    x.method();
+>x.method() : any
+>x.method : any
+>x : Promise<Foo> & Bar
+>method : any
+}
+

tests/baselines/reference/missingPropertyOfPromiseUnion.errors.txt

@@ -0,0 +1,21 @@
+tests/cases/compiler/missingPropertyOfPromiseUnion.ts(11,7): error TS2570: Property 'method' does not exist on type 'Promise<Foo> | Promise<Bar>'. Did you forget to await the 'Promise<Foo> | Promise<Bar>' as property 'method' exists on awaited 'Foo'?
+  Property 'method' does not exist on type 'Promise<Foo>'.
+
+
+==== tests/cases/compiler/missingPropertyOfPromiseUnion.ts (1 errors) ====
+    interface Foo {
+        method();
+    }
+
+    interface Bar {
+        method();
+        somethingElse();
+    }
+
+    function f(x: Promise<Foo> | Promise<Bar>) {
+        x.method();
+          ~~~~~~
+!!! error TS2570: Property 'method' does not exist on type 'Promise<Foo> | Promise<Bar>'. Did you forget to await the 'Promise<Foo> | Promise<Bar>' as property 'method' exists on awaited 'Foo'?
+!!! error TS2570:   Property 'method' does not exist on type 'Promise<Foo>'.
+    }
+

tests/baselines/reference/missingPropertyOfPromiseUnion.js

@@ -0,0 +1,19 @@
+//// [missingPropertyOfPromiseUnion.ts]
+interface Foo {
+    method();
+}
+
+interface Bar {
+    method();
+    somethingElse();
+}
+
+function f(x: Promise<Foo> | Promise<Bar>) {
+    x.method();
+}
+
+
+//// [missingPropertyOfPromiseUnion.js]
+function f(x) {
+    x.method();
+}

tests/baselines/reference/missingPropertyOfPromiseUnion.symbols

@@ -0,0 +1,30 @@
+=== tests/cases/compiler/missingPropertyOfPromiseUnion.ts ===
+interface Foo {
+>Foo : Symbol(Foo, Decl(missingPropertyOfPromiseUnion.ts, 0, 0))
+
+    method();
+>method : Symbol(Foo.method, Decl(missingPropertyOfPromiseUnion.ts, 0, 15))
+}
+
+interface Bar {
+>Bar : Symbol(Bar, Decl(missingPropertyOfPromiseUnion.ts, 2, 1))
+
+    method();
+>method : Symbol(Bar.method, Decl(missingPropertyOfPromiseUnion.ts, 4, 15))
+
+    somethingElse();
+>somethingElse : Symbol(Bar.somethingElse, Decl(missingPropertyOfPromiseUnion.ts, 5, 13))
+}
+
+function f(x: Promise<Foo> | Promise<Bar>) {
+>f : Symbol(f, Decl(missingPropertyOfPromiseUnion.ts, 7, 1))
+>x : Symbol(x, Decl(missingPropertyOfPromiseUnion.ts, 9, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
+>Foo : Symbol(Foo, Decl(missingPropertyOfPromiseUnion.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
+>Bar : Symbol(Bar, Decl(missingPropertyOfPromiseUnion.ts, 2, 1))
+
+    x.method();
+>x : Symbol(x, Decl(missingPropertyOfPromiseUnion.ts, 9, 11))
+}
+

tests/baselines/reference/missingPropertyOfPromiseUnion.types

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/missingPropertyOfPromiseUnion.ts ===
+interface Foo {
+>Foo : Foo
+
+    method();
+>method : () => any
+}
+
+interface Bar {
+>Bar : Bar
+
+    method();
+>method : () => any
+
+    somethingElse();
+>somethingElse : () => any
+}
+
+function f(x: Promise<Foo> | Promise<Bar>) {
+>f : (x: Promise<Foo> | Promise<Bar>) => void
+>x : Promise<Foo> | Promise<Bar>
+>Promise : Promise<T>
+>Foo : Foo
+>Promise : Promise<T>
+>Bar : Bar
+
+    x.method();
+>x.method() : any
+>x.method : any
+>x : Promise<Foo> | Promise<Bar>
+>method : any
+}
+

tests/cases/compiler/missingPropertyOfPromise.ts

@@ -0,0 +1,3 @@
+function f(x: Promise<string>) {
+    x.toLowerCase();
+}

tests/cases/compiler/missingPropertyOfPromiseIntersection.ts

@@ -0,0 +1,11 @@
+interface Foo {
+    method();
+}
+
+interface Bar {
+    somethingElse();
+}
+
+function f(x: Promise<Foo> & Bar) {
+    x.method();
+}

tests/cases/compiler/missingPropertyOfPromiseUnion.ts

@@ -0,0 +1,12 @@
+interface Foo {
+    method();
+}
+
+interface Bar {
+    method();
+    somethingElse();
+}
+
+function f(x: Promise<Foo> | Promise<Bar>) {
+    x.method();
+}