Overview

While using memoize in our code we identified an issue where the order of promise execution got scrambled by the use of memoize.
This PR fixes this issue.

Root cause

The first call to memoize with a certain key returns one promise, all subsequent calls to memoize with the same key return a different promise.
This is because the first call creates a new promise with the.catch call and returns it, but caches the original "inner" promise.
Following calls to memoize return only the "inner" promise.

Suggested fix

In the case of having a promise object as the result of the evaluated function, cache the complex promise with thecatch call in it.
This way the first and subsequent calls will return the same promise and all will register their events on it.

Details:

We are using memoize to memoize the suggested autocomplete entries for a text input in our web page, they all have the same cache key.
When the user is typing a string into the input, each letter invokes theonchange event that uses memoize and awaits the promise that fetches data from the server.

What we see is that when the promise returned by the memoized function is resolved, the first caller'sthen method is being invoked last (instead of first as expected).

Repro steps:

1. Call memoize with a promise returning function with key 'a' and await it.
2. While it's executing have one (or more) calls to the same key and await it.

Expected behavior - thethen statement from item1 is invoked before thethen statement of item2.

Note: also see the unit test in this PR to illustrate this scenario. This test is failing in the currentmaster branch.