Function addMemberForKeyTypeWorker

test/fixtures/snapshot/typescript.js:58563–58605

(keyType, propNameType)

                forEachType(propNameType, function (t) { return addMemberForKeyTypeWorker(keyType, t); });
            }
            function addMemberForKeyTypeWorker(keyType, propNameType) {
                // If the current iteration type constituent is a string literal type, create a property.
                // Otherwise, for type string create a string index signature.
                if (isTypeUsableAsPropertyName(propNameType)) {
                    var propName = getPropertyNameFromType(propNameType);
                    // String enum members from separate enums with identical values
                    // are distinct types with the same property name. Make the resulting
                    // property symbol's name type be the union of those enum member types.
                    var existingProp = members.get(propName);
                    if (existingProp) {
                        existingProp.nameType = getUnionType([existingProp.nameType, propNameType]);
                        existingProp.keyType = getUnionType([existingProp.keyType, keyType]);
                    }
                    else {
                        var modifiersProp = isTypeUsableAsPropertyName(keyType) ? getPropertyOfType(modifiersType, getPropertyNameFromType(keyType)) : undefined;
                        var isOptional = !!(templateModifiers & 4 /* MappedTypeModifiers.IncludeOptional */ ||
                            !(templateModifiers & 8 /* MappedTypeModifiers.ExcludeOptional */) && modifiersProp && modifiersProp.flags & 16777216 /* SymbolFlags.Optional */);
                        var isReadonly = !!(templateModifiers & 1 /* MappedTypeModifiers.IncludeReadonly */ ||
                            !(templateModifiers & 2 /* MappedTypeModifiers.ExcludeReadonly */) && modifiersProp && isReadonlySymbol(modifiersProp));
                        var stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216 /* SymbolFlags.Optional */;
                        var lateFlag = modifiersProp ? getIsLateCheckFlag(modifiersProp) : 0;
                        var prop = createSymbol(4 /* SymbolFlags.Property */ | (isOptional ? 16777216 /* SymbolFlags.Optional */ : 0), propName, lateFlag | 262144 /* CheckFlags.Mapped */ | (isReadonly ? 8 /* CheckFlags.Readonly */ : 0) | (stripOptional ? 524288 /* CheckFlags.StripOptional */ : 0));
                        prop.mappedType = type;
                        prop.nameType = propNameType;
                        prop.keyType = keyType;
                        if (modifiersProp) {
                            prop.syntheticOrigin = modifiersProp;
                            // If the mapped type has an `as XXX` clause, the property name likely won't match the declaration name and
                            // multiple properties may map to the same name. Thus, we attach no declarations to the symbol.
                            prop.declarations = nameType ? undefined : modifiersProp.declarations;
                        }
                        members.set(propName, prop);
                    }
                }
                else if (isValidIndexKeyType(propNameType) || propNameType.flags & (1 /* TypeFlags.Any */ | 32 /* TypeFlags.Enum */)) {
                    var indexKeyType = propNameType.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */) ? stringType :
                        propNameType.flags & (8 /* TypeFlags.Number */ | 32 /* TypeFlags.Enum */) ? numberType :
                            propNameType;
                    var propType = instantiateType(templateType, appendTypeMapping(type.mapper, typeParameter, keyType));
                    var indexInfo = createIndexInfo(indexKeyType, propType, !!(templateModifiers & 1 /* MappedTypeModifiers.IncludeReadonly */));
                    indexInfos = appendIndexInfo(indexInfos, indexInfo, /*union*/ true);
                }
            }
        }
        function getTypeOfMappedSymbol(symbol) {
            if (!symbol.type) {