Function getTypeFromTypeAliasReference

test/fixtures/snapshot/typescript.js:60319–60352

* Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the * declared type. Instantiations are cached u

(node, symbol)

         * declared type. Instantiations are cached using the type identities of the type arguments as the key.
         */
        function getTypeFromTypeAliasReference(node, symbol) {
            if (ts.getCheckFlags(symbol) & 1048576 /* CheckFlags.Unresolved */) {
                var typeArguments = typeArgumentsFromTypeReferenceNode(node);
                var id = getAliasId(symbol, typeArguments);
                var errorType_1 = errorTypes.get(id);
                if (!errorType_1) {
                    errorType_1 = createIntrinsicType(1 /* TypeFlags.Any */, "error");
                    errorType_1.aliasSymbol = symbol;
                    errorType_1.aliasTypeArguments = typeArguments;
                    errorTypes.set(id, errorType_1);
                }
                return errorType_1;
            }
            var type = getDeclaredTypeOfSymbol(symbol);
            var typeParameters = getSymbolLinks(symbol).typeParameters;
            if (typeParameters) {
                var numTypeArguments = ts.length(node.typeArguments);
                var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
                if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
                    error(node, minTypeArgumentCount === typeParameters.length ?
                        ts.Diagnostics.Generic_type_0_requires_1_type_argument_s :
                        ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments, symbolToString(symbol), minTypeArgumentCount, typeParameters.length);
                    return errorType;
                }
                // We refrain from associating a local type alias with an instantiation of a top-level type alias
                // because the local alias may end up being referenced in an inferred return type where it is not
                // accessible--which in turn may lead to a large structural expansion of the type when generating
                // a .d.ts file. See #43622 for an example.
                var aliasSymbol = getAliasSymbolForTypeNode(node);
                var newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : undefined;
                return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol));
            }
            return checkNoTypeArguments(node, symbol) ? type : errorType;
        }
        function isLocalTypeAlias(symbol) {
            var _a;
            var declaration = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isTypeAlias);