Function getIndexTypeForMappedType

test/fixtures/snapshot/typescript.js:61756–61799

* This roughly mirrors `resolveMappedTypeMembers` in the nongeneric case, except only reports a union of the keys calculated, * rather than manufacturing the properties. We can't just fetch the `constraintType` since that would ignore mappings * and mapping the `constraintType` dir

(type, stringsOnly, noIndexSignatures)

         * @param noIndexSignatures Indicates if _string_ index signatures should be elided. (other index signatures are always reported)
         */
        function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
            var typeParameter = getTypeParameterFromMappedType(type);
            var constraintType = getConstraintTypeFromMappedType(type);
            var nameType = getNameTypeFromMappedType(type.target || type);
            if (!nameType && !noIndexSignatures) {
                // no mapping and no filtering required, just quickly bail to returning the constraint in the common case
                return constraintType;
            }
            var keyTypes = [];
            if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                // We have a { [P in keyof T]: X }
                // `getApparentType` on the T in a generic mapped type can trigger a circularity
                // (conditionals and `infer` types create a circular dependency in the constraint resolution)
                // so we only eagerly manifest the keys if the constraint is nongeneric
                if (!isGenericIndexType(constraintType)) {
                    var modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); // The 'T' in 'keyof T'
                    forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
                }
                else {
                    // we have a generic index and a homomorphic mapping (but a distributive key remapping) - we need to defer the whole `keyof whatever` for later
                    // since it's not safe to resolve the shape of modifier type
                    return getIndexTypeForGenericType(type, stringsOnly);
                }
            }
            else {
                forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
            }
            if (isGenericIndexType(constraintType)) { // include the generic component in the resulting type
                forEachType(constraintType, addMemberForKeyType);
            }
            // we had to pick apart the constraintType to potentially map/filter it - compare the final resulting list with the original constraintType,
            // so we can return the union that preserves aliases/origin data if possible
            var result = noIndexSignatures ? filterType(getUnionType(keyTypes), function (t) { return !(t.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */)); }) : getUnionType(keyTypes);
            if (result.flags & 1048576 /* TypeFlags.Union */ && constraintType.flags & 1048576 /* TypeFlags.Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
                return constraintType;
            }
            return result;
            function addMemberForKeyType(keyType) {
                var propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
                // `keyof` currently always returns `string | number` for concrete `string` index signatures - the below ternary keeps that behavior for mapped types
                // See `getLiteralTypeFromProperties` where there's a similar ternary to cause the same behavior.
                keyTypes.push(propNameType === stringType ? stringOrNumberType : propNameType);
            }
        }
        // Ordinarily we reduce a keyof M, where M is a mapped type { [P in K as N<P>]: X }, to simply N<K>. This however presumes
        // that N distributes over union types, i.e. that N<A | B | C> is equivalent to N<A> | N<B> | N<C>. Specifically, we only
        // want to perform the reduction when the name type of a mapped type is distributive with respect to the type variable