Function createAwaitedTypeIfNeeded

test/fixtures/snapshot/typescript.js:81353–81385

(type)

                    type;
        }
        function createAwaitedTypeIfNeeded(type) {
            // We wrap type `T` in `Awaited<T>` based on the following conditions:
            // - `T` is not already an `Awaited<U>`, and
            // - `T` is generic, and
            // - One of the following applies:
            //   - `T` has no base constraint, or
            //   - The base constraint of `T` is `any`, `unknown`, `object`, or `{}`, or
            //   - The base constraint of `T` is an object type with a callable `then` method.
            if (isTypeAny(type)) {
                return type;
            }
            // If this is already an `Awaited<T>`, just return it. This helps to avoid `Awaited<Awaited<T>>` in higher-order.
            if (isAwaitedTypeInstantiation(type)) {
                return type;
            }
            // Only instantiate `Awaited<T>` if `T` contains possibly non-primitive types.
            if (isGenericObjectType(type)) {
                var baseConstraint = getBaseConstraintOfType(type);
                // Only instantiate `Awaited<T>` if `T` has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`,
                // or is promise-like.
                if (!baseConstraint || (baseConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */) || isEmptyObjectType(baseConstraint) || isThenableType(baseConstraint)) {
                    // Nothing to do if `Awaited<T>` doesn't exist
                    var awaitedSymbol = getGlobalAwaitedSymbol(/*reportErrors*/ true);
                    if (awaitedSymbol) {
                        // Unwrap unions that may contain `Awaited<T>`, otherwise its possible to manufacture an `Awaited<Awaited<T> | U>` where
                        // an `Awaited<T | U>` would suffice.
                        return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
                    }
                }
            }
            ts.Debug.assert(getPromisedTypeOfPromise(type) === undefined, "type provided should not be a non-generic 'promise'-like.");
            return type;
        }
        /**
         * Gets the "awaited type" of a type.
         *