Function getWidenedTypeForAssignmentDeclaration

test/fixtures/snapshot/typescript.js:56156–56230

(symbol, resolvedSymbol)

            return getFlowTypeOfReference(reference, autoType, initialType);
        }
        function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
            // function/class/{} initializers are themselves containers, so they won't merge in the same way as other initializers
            var container = ts.getAssignedExpandoInitializer(symbol.valueDeclaration);
            if (container) {
                var tag = ts.getJSDocTypeTag(container);
                if (tag && tag.typeExpression) {
                    return getTypeFromTypeNode(tag.typeExpression);
                }
                var containerObjectType = symbol.valueDeclaration && getJSContainerObjectType(symbol.valueDeclaration, symbol, container);
                return containerObjectType || getWidenedLiteralType(checkExpressionCached(container));
            }
            var type;
            var definedInConstructor = false;
            var definedInMethod = false;
            // We use control flow analysis to determine the type of the property if the property qualifies as a constructor
            // declared property and the resulting control flow type isn't just undefined or null.
            if (isConstructorDeclaredProperty(symbol)) {
                type = getFlowTypeInConstructor(symbol, getDeclaringConstructor(symbol));
            }
            if (!type) {
                var types = void 0;
                if (symbol.declarations) {
                    var jsdocType = void 0;
                    for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                        var declaration = _a[_i];
                        var expression = (ts.isBinaryExpression(declaration) || ts.isCallExpression(declaration)) ? declaration :
                            ts.isAccessExpression(declaration) ? ts.isBinaryExpression(declaration.parent) ? declaration.parent : declaration :
                                undefined;
                        if (!expression) {
                            continue; // Non-assignment declaration merged in (eg, an Identifier to mark the thing as a namespace) - skip over it and pull type info from elsewhere
                        }
                        var kind = ts.isAccessExpression(expression)
                            ? ts.getAssignmentDeclarationPropertyAccessKind(expression)
                            : ts.getAssignmentDeclarationKind(expression);
                        if (kind === 4 /* AssignmentDeclarationKind.ThisProperty */ || ts.isBinaryExpression(expression) && isPossiblyAliasedThisProperty(expression, kind)) {
                            if (isDeclarationInConstructor(expression)) {
                                definedInConstructor = true;
                            }
                            else {
                                definedInMethod = true;
                            }
                        }
                        if (!ts.isCallExpression(expression)) {
                            jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration);
                        }
                        if (!jsdocType) {
                            (types || (types = [])).push((ts.isBinaryExpression(expression) || ts.isCallExpression(expression)) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType);
                        }
                    }
                    type = jsdocType;
                }
                if (!type) {
                    if (!ts.length(types)) {
                        return errorType; // No types from any declarations :(
                    }
                    var constructorTypes = definedInConstructor && symbol.declarations ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : undefined;
                    // use only the constructor types unless they were only assigned null | undefined (including widening variants)
                    if (definedInMethod) {