Function getInferredTypeParameterConstraint

test/fixtures/snapshot/typescript.js:60066–60133

(typeParameter, omitTypeReferences)

            return ts.mapDefined(ts.filter(type.symbol && type.symbol.declarations, ts.isTypeParameterDeclaration), ts.getEffectiveConstraintOfTypeParameter)[0];
        }
        function getInferredTypeParameterConstraint(typeParameter, omitTypeReferences) {
            var _a;
            var inferences;
            if ((_a = typeParameter.symbol) === null || _a === void 0 ? void 0 : _a.declarations) {
                for (var _i = 0, _b = typeParameter.symbol.declarations; _i < _b.length; _i++) {
                    var declaration = _b[_i];
                    if (declaration.parent.kind === 190 /* SyntaxKind.InferType */) {
                        // When an 'infer T' declaration is immediately contained in a type reference node
                        // (such as 'Foo<infer T>'), T's constraint is inferred from the constraint of the
                        // corresponding type parameter in 'Foo'. When multiple 'infer T' declarations are
                        // present, we form an intersection of the inferred constraint types.
                        var _c = ts.walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent), _d = _c[0], childTypeParameter = _d === void 0 ? declaration.parent : _d, grandParent = _c[1];
                        if (grandParent.kind === 178 /* SyntaxKind.TypeReference */ && !omitTypeReferences) {
                            var typeReference = grandParent;
                            var typeParameters = getTypeParametersForTypeReference(typeReference);
                            if (typeParameters) {
                                var index = typeReference.typeArguments.indexOf(childTypeParameter);
                                if (index < typeParameters.length) {
                                    var declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]);
                                    if (declaredConstraint) {
                                        // Type parameter constraints can reference other type parameters so
                                        // constraints need to be instantiated. If instantiation produces the
                                        // type parameter itself, we discard that inference. For example, in
                                        //   type Foo<T extends string, U extends T> = [T, U];
                                        //   type Bar<T> = T extends Foo<infer X, infer X> ? Foo<X, X> : T;
                                        // the instantiated constraint for U is X, so we discard that inference.
                                        var mapper = createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReference, typeParameters));
                                        var constraint = instantiateType(declaredConstraint, mapper);
                                        if (constraint !== typeParameter) {
                                            inferences = ts.append(inferences, constraint);
                                        }
                                    }
                                }
                            }
                        }
                        // When an 'infer T' declaration is immediately contained in a rest parameter declaration, a rest type
                        // or a named rest tuple element, we infer an 'unknown[]' constraint.
                        else if (grandParent.kind === 164 /* SyntaxKind.Parameter */ && grandParent.dotDotDotToken ||
                            grandParent.kind === 186 /* SyntaxKind.RestType */ ||
                            grandParent.kind === 197 /* SyntaxKind.NamedTupleMember */ && grandParent.dotDotDotToken) {
                            inferences = ts.append(inferences, createArrayType(unknownType));
                        }
                        // When an 'infer T' declaration is immediately contained in a string template type, we infer a 'string'
                        // constraint.
                        else if (grandParent.kind === 199 /* SyntaxKind.TemplateLiteralTypeSpan */) {
                            inferences = ts.append(inferences, stringType);
                        }
                        // When an 'infer T' declaration is in the constraint position of a mapped type, we infer a 'keyof any'
                        // constraint.
                        else if (grandParent.kind === 163 /* SyntaxKind.TypeParameter */ && grandParent.parent.kind === 195 /* SyntaxKind.MappedType */) {
                            inferences = ts.append(inferences, keyofConstraintType);
                        }
                        // When an 'infer T' declaration is the template of a mapped type, and that mapped type is the extends
                        // clause of a conditional whose check type is also a mapped type, give it a constraint equal to the template
                        // of the check type's mapped type
                        else if (grandParent.kind === 195 /* SyntaxKind.MappedType */ && grandParent.type &&
                            ts.skipParentheses(grandParent.type) === declaration.parent && grandParent.parent.kind === 189 /* SyntaxKind.ConditionalType */ &&
                            grandParent.parent.extendsType === grandParent && grandParent.parent.checkType.kind === 195 /* SyntaxKind.MappedType */ &&