@zzzen/pyright-internal 1.2.0-dev.20230507 → 1.2.0-dev.20230521

package/dist/analyzer/typePrinter.js

@@ -27,7 +27,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printFunctionParts = exports.printObjectTypeForClass = exports.printLiteralValue = exports.printType = exports.PrintTypeFlags = void 0;
+exports.printLiteralValue = exports.printObjectTypeForClass = exports.printFunctionParts = exports.printType = exports.PrintTypeFlags = void 0;
+const collectionUtils_1 = require("../common/collectionUtils");
 const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const types_1 = require("./types");
@@ -63,7 +64,90 @@ var PrintTypeFlags;
     // Expand TypedDict kwargs to show the keys from the TypedDict instead of **kwargs.
     PrintTypeFlags[PrintTypeFlags["ExpandTypedDictArgs"] = 1024] = "ExpandTypedDictArgs";
 })(PrintTypeFlags = exports.PrintTypeFlags || (exports.PrintTypeFlags = {}));
-function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = [], recursionCount = 0) {
+function printType(type, printTypeFlags, returnTypeCallback) {
+    const uniqueNameMap = new UniqueNameMap(printTypeFlags, returnTypeCallback);
+    uniqueNameMap.build(type);
+    return printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, [], 0);
+}
+exports.printType = printType;
+function printFunctionParts(type, printTypeFlags, returnTypeCallback) {
+    const uniqueNameMap = new UniqueNameMap(printTypeFlags, returnTypeCallback);
+    uniqueNameMap.build(type);
+    return printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, [], 0);
+}
+exports.printFunctionParts = printFunctionParts;
+function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback) {
+    const uniqueNameMap = new UniqueNameMap(printTypeFlags, returnTypeCallback);
+    uniqueNameMap.build(type);
+    return printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, [], 0);
+}
+exports.printObjectTypeForClass = printObjectTypeForClass;
+function printLiteralValue(type, quotation = "'") {
+    const literalValue = type.literalValue;
+    if (literalValue === undefined) {
+        return '';
+    }
+    let literalStr;
+    if (typeof literalValue === 'string') {
+        let effectiveLiteralValue = literalValue;
+        // Limit the length of the string literal.
+        const maxLiteralStringLength = 50;
+        if (literalValue.length > maxLiteralStringLength) {
+            effectiveLiteralValue = literalValue.substring(0, maxLiteralStringLength) + '…';
+        }
+        if (type.details.name === 'bytes') {
+            let bytesString = '';
+            // There's no good built-in conversion routine in javascript to convert
+            // bytes strings. Determine on a character-by-character basis whether
+            // it can be rendered into an ASCII character. If not, use an escape.
+            for (let i = 0; i < effectiveLiteralValue.length; i++) {
+                const char = effectiveLiteralValue.substring(i, i + 1);
+                const charCode = char.charCodeAt(0);
+                if (charCode >= 20 && charCode <= 126) {
+                    if (charCode === 34) {
+                        bytesString += '\\' + char;
+                    }
+                    else {
+                        bytesString += char;
+                    }
+                }
+                else {
+                    bytesString += `\\x${((charCode >> 4) & 0xf).toString(16)}${(charCode & 0xf).toString(16)}`;
+                }
+            }
+            literalStr = `b"${bytesString}"`;
+        }
+        else {
+            // JSON.stringify will perform proper escaping for " case.
+            // So, we only need to do our own escaping for ' case.
+            literalStr = JSON.stringify(effectiveLiteralValue).toString();
+            if (quotation !== '"') {
+                literalStr = `'${literalStr
+                    .substring(1, literalStr.length - 1)
+                    .replace(escapedDoubleQuoteRegEx, '"')
+                    .replace(singleTickRegEx, "\\'")}'`;
+            }
+        }
+    }
+    else if (typeof literalValue === 'boolean') {
+        literalStr = literalValue ? 'True' : 'False';
+    }
+    else if (literalValue instanceof types_1.EnumLiteral) {
+        literalStr = `${literalValue.className}.${literalValue.itemName}`;
+    }
+    else if (typeof literalValue === 'bigint') {
+        literalStr = literalValue.toString();
+        if (literalStr.endsWith('n')) {
+            literalStr = literalStr.substring(0, literalStr.length - 1);
+        }
+    }
+    else {
+        literalStr = literalValue.toString();
+    }
+    return literalStr;
+}
+exports.printLiteralValue = printLiteralValue;
+function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
     const originalPrintTypeFlags = printTypeFlags;
     const parenthesizeUnion = (printTypeFlags & 16 /* ParenthesizeUnion */) !== 0;
     printTypeFlags &= ~(16 /* ParenthesizeUnion */ | 128 /* ParenthesizeCallable */);
@@ -90,6 +174,10 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
             try {
                 recursionTypes.push(type);
                 let aliasName = type.typeAliasInfo.name;
+                // Use the fully-qualified name if the name isn't unique.
+                if (!uniqueNameMap.isUnique(aliasName)) {
+                    aliasName = type.typeAliasInfo.fullName;
+                }
                 const typeParams = type.typeAliasInfo.typeParameters;
                 if (typeParams) {
                     let argumentStrings;
@@ -107,11 +195,11 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                                     (0, typeUtils_1.isTupleClass)(typeArg) &&
                                     typeArg.tupleTypeArguments) {
                                     typeArg.tupleTypeArguments.forEach((tupleTypeArg) => {
-                                        argumentStrings.push(printType(tupleTypeArg.type, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                                        argumentStrings.push(printTypeInternal(tupleTypeArg.type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                                     });
                                 }
                                 else {
-                                    argumentStrings.push(printType(typeArg, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                                    argumentStrings.push(printTypeInternal(typeArg, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                                 }
                             });
                         }
@@ -121,7 +209,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                             typeParams.some((typeParam) => !(0, types_1.isUnknown)(typeParam))) {
                             argumentStrings = [];
                             typeParams.forEach((typeParam) => {
-                                argumentStrings.push(printType(typeParam, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                                argumentStrings.push(printTypeInternal(typeParam, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                             });
                         }
                     }
@@ -158,11 +246,15 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
         }
         if (type.typeAliasInfo) {
             if (!type.typeAliasInfo.typeParameters) {
-                return type.typeAliasInfo.name;
+                let name = type.typeAliasInfo.name;
+                if (!uniqueNameMap.isUnique(name)) {
+                    name = type.typeAliasInfo.fullName;
+                }
+                return name;
             }
             try {
                 recursionTypes.push(type);
-                return printType(type, printTypeFlags & ~32 /* ExpandTypeAlias */, returnTypeCallback, recursionTypes, recursionCount);
+                return printTypeInternal(type, printTypeFlags & ~32 /* ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
             }
             finally {
                 recursionTypes.pop();
@@ -200,7 +292,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                     if (type.literalValue !== undefined) {
                         return `Literal[${printLiteralValue(type)}]`;
                     }
-                    return `${printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recursionTypes)}${getConditionalIndicator(type)}`;
+                    return `${printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)}${getConditionalIndicator(type)}`;
                 }
                 else {
                     let typeToWrap;
@@ -208,21 +300,21 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                         typeToWrap = `Literal[${printLiteralValue(type)}]`;
                     }
                     else {
-                        typeToWrap = `${printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recursionTypes)}`;
+                        typeToWrap = `${printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)}`;
                     }
                     return `${_printNestedInstantiable(type, typeToWrap)}${getConditionalIndicator(type)}`;
                 }
             }
             case 5 /* Function */: {
                 if (types_1.TypeBase.isInstantiable(type)) {
-                    const typeString = printFunctionType(types_1.TypeBase.cloneTypeAsInstance(type), printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                    const typeString = printFunctionType(types_1.TypeBase.cloneTypeAsInstance(type), printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                     return `Type[${typeString}]`;
                 }
-                return printFunctionType(type, originalPrintTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                return printFunctionType(type, originalPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
             }
             case 6 /* OverloadedFunction */: {
                 const overloadedType = type;
-                const overloads = overloadedType.overloads.map((overload) => printType(overload, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                const overloads = overloadedType.overloads.map((overload) => printTypeInternal(overload, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                 if (printTypeFlags & 256 /* PythonSyntax */) {
                     return 'Callable[..., Any]';
                 }
@@ -266,7 +358,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                             }
                         }
                         if (matchedAllSubtypes && !allSubtypesPreviouslyHandled) {
-                            subtypeStrings.add(printType(typeAliasSource, updatedPrintTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                            subtypeStrings.add(printTypeInternal(typeAliasSource, updatedPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                             indicesCoveredByTypeAlias.forEach((index) => subtypeHandledSet.add(index));
                         }
                     }
@@ -277,7 +369,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                     if ((0, types_1.isNever)(typeWithoutNone)) {
                         return 'None';
                     }
-                    const optionalType = printType(typeWithoutNone, updatedPrintTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                    const optionalType = printTypeInternal(typeWithoutNone, updatedPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                     if (printTypeFlags & 8 /* PEP604 */) {
                         const unionString = optionalType + ' | None';
                         if (parenthesizeUnion) {
@@ -298,7 +390,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                             literalClassStrings.add(printLiteralValue(subtype));
                         }
                         else {
-                            subtypeStrings.add(printType(subtype, updatedPrintTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                            subtypeStrings.add(printTypeInternal(subtype, updatedPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                         }
                     }
                 });
@@ -336,9 +428,9 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                     // aliases, return the type alias name.
                     if (type.details.recursiveTypeAliasName) {
                         if ((printTypeFlags & 32 /* ExpandTypeAlias */) !== 0 && type.details.boundType) {
-                            return printType(types_1.TypeBase.isInstance(type)
+                            return printTypeInternal(types_1.TypeBase.isInstance(type)
                                 ? (0, typeUtils_1.convertToInstance)(type.details.boundType)
-                                : type.details.boundType, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                                : type.details.boundType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                         }
                         return type.details.recursiveTypeAliasName;
                     }
@@ -346,7 +438,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
                     // print the type with a special character that indicates that the type
                     // is internally represented as a TypeVar.
                     if (type.details.isSynthesizedSelf && type.details.boundType) {
-                        let boundTypeString = printType(type.details.boundType, printTypeFlags & ~32 /* ExpandTypeAlias */, returnTypeCallback, recursionTypes, recursionCount);
+                        let boundTypeString = printTypeInternal(type.details.boundType, printTypeFlags & ~32 /* ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                         if (!(0, types_1.isAnyOrUnknown)(type.details.boundType)) {
                             if (printTypeFlags & 256 /* PythonSyntax */) {
                                 boundTypeString = `Self`;
@@ -399,8 +491,7 @@ function printType(type, printTypeFlags, returnTypeCallback, recursionTypes = []
         recursionTypes.pop();
     }
 }
-exports.printType = printType;
-function printFunctionType(type, printTypeFlags, returnTypeCallback, recursionTypes = [], recursionCount = 0) {
+function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
     if (printTypeFlags & 256 /* PythonSyntax */) {
         // Callable works only in cases where all parameters are positional-only.
         let isPositionalParamsOnly = false;
@@ -418,7 +509,7 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, recursionTy
         const returnType = returnTypeCallback(type);
         let returnTypeString = 'Any';
         if (returnType) {
-            returnTypeString = printType(returnType, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+            returnTypeString = printTypeInternal(returnType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
         }
         if (isPositionalParamsOnly) {
             const paramTypes = [];
@@ -426,7 +517,7 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, recursionTy
                 if (param.name) {
                     const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
                     if (recursionTypes.length < types_1.maxTypeRecursionCount) {
-                        paramTypes.push(printType(paramType, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
+                        paramTypes.push(printTypeInternal(paramType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                     }
                     else {
                         paramTypes.push('Any');
@@ -448,7 +539,7 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, recursionTy
         }
     }
     else {
-        const parts = printFunctionParts(type, printTypeFlags, returnTypeCallback, recursionTypes);
+        const parts = printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
         const paramSignature = `(${parts[0].join(', ')})`;
         if (types_1.FunctionType.isParamSpecValue(type)) {
             return paramSignature;
@@ -461,74 +552,13 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, recursionTy
         return fullSignature;
     }
 }
-function printLiteralValue(type, quotation = "'") {
-    const literalValue = type.literalValue;
-    if (literalValue === undefined) {
-        return '';
-    }
-    let literalStr;
-    if (typeof literalValue === 'string') {
-        let effectiveLiteralValue = literalValue;
-        // Limit the length of the string literal.
-        const maxLiteralStringLength = 50;
-        if (literalValue.length > maxLiteralStringLength) {
-            effectiveLiteralValue = literalValue.substring(0, maxLiteralStringLength) + '…';
-        }
-        if (type.details.name === 'bytes') {
-            let bytesString = '';
-            // There's no good built-in conversion routine in javascript to convert
-            // bytes strings. Determine on a character-by-character basis whether
-            // it can be rendered into an ASCII character. If not, use an escape.
-            for (let i = 0; i < effectiveLiteralValue.length; i++) {
-                const char = effectiveLiteralValue.substring(i, i + 1);
-                const charCode = char.charCodeAt(0);
-                if (charCode >= 20 && charCode <= 126) {
-                    if (charCode === 34) {
-                        bytesString += '\\' + char;
-                    }
-                    else {
-                        bytesString += char;
-                    }
-                }
-                else {
-                    bytesString += `\\x${((charCode >> 4) & 0xf).toString(16)}${(charCode & 0xf).toString(16)}`;
-                }
-            }
-            literalStr = `b"${bytesString}"`;
-        }
-        else {
-            // JSON.stringify will perform proper escaping for " case.
-            // So, we only need to do our own escaping for ' case.
-            literalStr = JSON.stringify(effectiveLiteralValue).toString();
-            if (quotation !== '"') {
-                literalStr = `'${literalStr
-                    .substring(1, literalStr.length - 1)
-                    .replace(escapedDoubleQuoteRegEx, '"')
-                    .replace(singleTickRegEx, "\\'")}'`;
-            }
-        }
-    }
-    else if (typeof literalValue === 'boolean') {
-        literalStr = literalValue ? 'True' : 'False';
-    }
-    else if (literalValue instanceof types_1.EnumLiteral) {
-        literalStr = `${literalValue.className}.${literalValue.itemName}`;
-    }
-    else if (typeof literalValue === 'bigint') {
-        literalStr = literalValue.toString();
-        if (literalStr.endsWith('n')) {
-            literalStr = literalStr.substring(0, literalStr.length - 1);
-        }
-    }
-    else {
-        literalStr = literalValue.toString();
-    }
-    return literalStr;
-}
-exports.printLiteralValue = printLiteralValue;
-function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recursionTypes = [], recursionCount = 0) {
+function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
     var _a, _b;
     let objName = type.aliasName || type.details.name;
+    // Use the fully-qualified name if the name isn't unique.
+    if (!uniqueNameMap.isUnique(objName)) {
+        objName = type.details.fullName;
+    }
     // If this is a pseudo-generic class, don't display the type arguments
     // or type parameters because it will confuse users.
     if (!types_1.ClassType.isPseudoGenericClass(type)) {
@@ -561,11 +591,11 @@ function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recur
                             }
                         }
                         else {
-                            typeArgStrings.push(...typeArg.type.tupleTypeArguments.map((typeArg) => {
+                            (0, collectionUtils_1.appendArray)(typeArgStrings, typeArg.type.tupleTypeArguments.map((typeArg) => {
                                 if (!(0, types_1.isUnknown)(typeArg.type)) {
                                     isAllUnknown = false;
                                 }
-                                const typeArgText = printType(typeArg.type, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                                const typeArgText = printTypeInternal(typeArg.type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                                 if (typeArg.isUnbounded) {
                                     return _printUnpack(`tuple[${typeArgText}, ...]`, printTypeFlags);
                                 }
@@ -577,7 +607,7 @@ function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recur
                         if (!(0, types_1.isUnknown)(typeArg.type)) {
                             isAllUnknown = false;
                         }
-                        const typeArgTypeText = printType(typeArg.type, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                        const typeArgTypeText = printTypeInternal(typeArg.type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                         if (typeArg.isUnbounded) {
                             if (typeArgs.length === 1) {
                                 typeArgStrings.push(typeArgTypeText, '...');
@@ -618,7 +648,7 @@ function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recur
                         '[' +
                             typeParams
                                 .map((typeParam) => {
-                                return printType(typeParam, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                                return printTypeInternal(typeParam, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                             })
                                 .join(', ') +
                             ']';
@@ -626,10 +656,15 @@ function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback, recur
             }
         }
     }
+    // Wrap in a "Partial" for TypedDict that has been synthesized as partial.
+    if (type.isTypedDictPartial) {
+        if ((printTypeFlags & 256 /* PythonSyntax */) === 0) {
+            objName = `Partial[${objName}]`;
+        }
+    }
     return objName;
 }
-exports.printObjectTypeForClass = printObjectTypeForClass;
-function printFunctionParts(type, printTypeFlags, returnTypeCallback, recursionTypes = [], recursionCount = 0) {
+function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
     const paramTypeStrings = [];
     let sawDefinedName = false;
     type.details.parameters.forEach((param, index) => {
@@ -642,7 +677,7 @@ function printFunctionParts(type, printTypeFlags, returnTypeCallback, recursionT
                 types_1.ClassType.isBuiltIn(specializedParamType, 'tuple') &&
                 specializedParamType.tupleTypeArguments) {
                 specializedParamType.tupleTypeArguments.forEach((paramType) => {
-                    const paramString = printType(paramType.type, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                    const paramString = printTypeInternal(paramType.type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                     paramTypeStrings.push(paramString);
                 });
                 return;
@@ -653,7 +688,7 @@ function printFunctionParts(type, printTypeFlags, returnTypeCallback, recursionT
             printTypeFlags & 1024 /* ExpandTypedDictArgs */ &&
             param.type.category === 7 /* Class */) {
             param.type.details.typedDictEntries.forEach((v, k) => {
-                const valueTypeString = printType(v.valueType, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
+                const valueTypeString = printTypeInternal(v.valueType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                 paramTypeStrings.push(`${k}: ${valueTypeString}`);
             });
             return;
@@ -685,7 +720,7 @@ function printFunctionParts(type, printTypeFlags, returnTypeCallback, recursionT
             if (param.hasDeclaredType || param.isTypeInferred) {
                 const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
                 let paramTypeString = recursionTypes.length < types_1.maxTypeRecursionCount
-                    ? printType(paramType, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount)
+                    ? printTypeInternal(paramType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)
                     : '';
                 if (emittedParamName) {
                     paramString += ': ';
@@ -763,16 +798,15 @@ function printFunctionParts(type, printTypeFlags, returnTypeCallback, recursionT
             paramTypeStrings.push(`**kwargs: ${type.details.paramSpec}.kwargs`);
         }
         else {
-            paramTypeStrings.push(`**${printType(type.details.paramSpec, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount)}`);
+            paramTypeStrings.push(`**${printTypeInternal(type.details.paramSpec, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)}`);
         }
     }
     const returnType = returnTypeCallback(type);
     const returnTypeString = recursionTypes.length < types_1.maxTypeRecursionCount
-        ? printType(returnType, printTypeFlags | 16 /* ParenthesizeUnion */ | 128 /* ParenthesizeCallable */, returnTypeCallback, recursionTypes, recursionCount)
+        ? printTypeInternal(returnType, printTypeFlags | 16 /* ParenthesizeUnion */ | 128 /* ParenthesizeCallable */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)
         : '';
     return [paramTypeStrings, returnTypeString];
 }
-exports.printFunctionParts = printFunctionParts;
 function _printUnpack(textToWrap, flags) {
     return flags & 512 /* UseTypingUnpack */ ? `Unpack[${textToWrap}]` : `*${textToWrap}`;
 }
@@ -792,4 +826,124 @@ function _getReadableTypeVarName(type, usePythonSyntax) {
     }
     return types_1.TypeVarType.getReadableName(type);
 }
+// Represents a map of named types (classes and type aliases) that appear within
+// a specified type to determine whether any of the names require disambiguation
+// (i.e. their fully-qualified name is required).
+class UniqueNameMap {
+    constructor(_printTypeFlags, _returnTypeCallback) {
+        this._printTypeFlags = _printTypeFlags;
+        this._returnTypeCallback = _returnTypeCallback;
+        this._map = new Map();
+    }
+    build(type, recursionTypes = [], recursionCount = 0) {
+        var _a;
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return;
+        }
+        recursionCount++;
+        if (type.typeAliasInfo) {
+            let expandTypeAlias = true;
+            if ((this._printTypeFlags & 32 /* ExpandTypeAlias */) === 0) {
+                expandTypeAlias = false;
+            }
+            else {
+                if (recursionTypes.find((t) => t === type)) {
+                    expandTypeAlias = false;
+                }
+            }
+            if (!expandTypeAlias) {
+                this._addIfUnique(type.typeAliasInfo.name, type, /* useTypeAliasName */ true);
+                // Recursively add the type arguments if present.
+                if (type.typeAliasInfo.typeArguments) {
+                    recursionTypes.push(type);
+                    try {
+                        type.typeAliasInfo.typeArguments.forEach((typeArg) => {
+                            this.build(typeArg, recursionTypes, recursionCount);
+                        });
+                    }
+                    finally {
+                        recursionTypes.pop();
+                    }
+                }
+                return;
+            }
+        }
+        try {
+            recursionTypes.push(type);
+            switch (type.category) {
+                case 5 /* Function */: {
+                    type.details.parameters.forEach((_, index) => {
+                        const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
+                        this.build(paramType, recursionTypes, recursionCount);
+                    });
+                    const returnType = this._returnTypeCallback(type);
+                    this.build(returnType, recursionTypes, recursionCount);
+                    break;
+                }
+                case 6 /* OverloadedFunction */: {
+                    type.overloads.forEach((overload) => {
+                        this.build(overload, recursionTypes, recursionCount);
+                    });
+                    break;
+                }
+                case 7 /* Class */: {
+                    if (type.literalValue !== undefined) {
+                        break;
+                    }
+                    this._addIfUnique(type.aliasName || type.details.name, type);
+                    if (!types_1.ClassType.isPseudoGenericClass(type)) {
+                        if (type.tupleTypeArguments) {
+                            type.tupleTypeArguments.forEach((typeArg) => {
+                                this.build(typeArg.type, recursionTypes, recursionCount);
+                            });
+                        }
+                        else if (type.typeArguments) {
+                            type.typeArguments.forEach((typeArg) => {
+                                this.build(typeArg, recursionTypes, recursionCount);
+                            });
+                        }
+                    }
+                    break;
+                }
+                case 9 /* Union */: {
+                    (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                        this.build(subtype, recursionTypes, recursionCount);
+                    });
+                    (_a = type.typeAliasSources) === null || _a === void 0 ? void 0 : _a.forEach((typeAliasSource) => {
+                        this.build(typeAliasSource, recursionTypes, recursionCount);
+                    });
+                    break;
+                }
+            }
+        }
+        finally {
+            recursionTypes.pop();
+        }
+    }
+    isUnique(name) {
+        const entry = this._map.get(name);
+        return !entry || entry.length === 1;
+    }
+    _addIfUnique(name, type, useTypeAliasName = false) {
+        const existingEntry = this._map.get(name);
+        if (!existingEntry) {
+            this._map.set(name, [type]);
+        }
+        else {
+            if (!existingEntry.some((t) => this._isSameTypeName(t, type, useTypeAliasName))) {
+                existingEntry.push(type);
+            }
+        }
+    }
+    _isSameTypeName(type1, type2, useTypeAliasName) {
+        var _a, _b;
+        if (useTypeAliasName) {
+            return ((_a = type1.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.fullName) === ((_b = type2.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName);
+        }
+        if ((0, types_1.isClass)(type1) && (0, types_1.isClass)(type2)) {
+            return types_1.ClassType.isSameGenericClass(type1, type2);
+        }
+        return false;
+    }
+}
 //# sourceMappingURL=typePrinter.js.map