@zzzen/pyright-internal 1.2.0-dev.20231203 → 1.2.0-dev.20231210

package/dist/analyzer/typeEvaluator.js

@@ -47,6 +47,7 @@ const diagnosticRules_1 = require("../common/diagnosticRules");
 const positionUtils_1 = require("../common/positionUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
 const textRange_1 = require("../common/textRange");
+const uri_1 = require("../common/uri/uri");
 const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const parser_1 = require("../parser/parser");
@@ -262,7 +263,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const message = `Type cache flag mismatch for node type ${node.nodeType} ` +
                         `(parent ${(_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== null && _b !== void 0 ? _b : 'none'}): ` +
                         `cached flags = ${expectedFlags}, access flags = ${flags}, ` +
-                        `file = {${fileInfo.filePath} [${position.line + 1}:${position.character + 1}]}`;
+                        `file = {${fileInfo.fileUri} [${position.line + 1}:${position.character + 1}]}`;
                     if (evaluatorOptions.verifyTypeCacheEvaluatorFlags) {
                         (0, debug_1.fail)(message);
                     }
@@ -1407,9 +1408,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
-            const unknownFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
-            types_1.FunctionType.addDefaultParameters(unknownFunction);
-            return unknownFunction;
+            return (0, typeUtils_1.getUnknownTypeForCallable)();
         }
         return undefined;
     }
@@ -1923,7 +1922,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfModule(node, symbolName, nameParts) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        const lookupResult = importLookup({ nameParts, importingFilePath: fileInfo.filePath });
+        const lookupResult = importLookup({ nameParts, importingFileUri: fileInfo.fileUri });
         if (!lookupResult) {
             return undefined;
         }
@@ -2473,9 +2472,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, types_1.isFunction)(subtype) &&
                 subtype.details.parameters.length === 0 &&
                 subtype.details.paramSpec) {
-                const concreteFunction = types_1.FunctionType.createInstance('', '', '', 64 /* FunctionTypeFlags.SynthesizedMethod */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
-                types_1.FunctionType.addDefaultParameters(concreteFunction);
-                return types_1.FunctionType.cloneForParamSpec(subtype, concreteFunction);
+                return types_1.FunctionType.cloneForParamSpec(subtype, (0, typeUtils_1.getUnknownTypeForCallable)());
             }
             if ((0, types_1.isTypeVar)(subtype) && subtype.details.isVariadic) {
                 // If it's in a union, convert to type or object.
@@ -3072,7 +3069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return type;
     }
     // Handles the case where a variable or parameter is defined in an outer
-    // scope and captured by an inner scope (either a function or a lambda).
+    // scope and captured by an inner scope (a function, lambda, or comprehension).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
         // This function applies only to variables, parameters, and imports, not to other
         // types of symbols.
@@ -3092,16 +3089,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the symbol is a variable captured by an inner function
         // or lambda, see if we can infer the type from the outer scope.
         const scopeHierarchy = ScopeUtils.getScopeHierarchy(node, symbolWithScope.scope);
-        // Handle the case where all of the nested scopes are functions,
-        // lambdas and modules. Don't allow other types of scopes.
-        if (scopeHierarchy &&
-            scopeHierarchy.length >= 2 &&
-            scopeHierarchy.every((s) => s.type === 1 /* ScopeType.Function */ || s.type === 3 /* ScopeType.Module */)) {
+        if (scopeHierarchy && scopeHierarchy.length >= 2) {
             // Find the parse node associated with the scope that is just inside of the
             // scope that declares the captured variable.
             const innerScopeNode = ScopeUtils.findTopNodeInScope(node, scopeHierarchy[scopeHierarchy.length - 2]);
-            if (innerScopeNode &&
-                (innerScopeNode.nodeType === 28 /* ParseNodeType.Function */ || innerScopeNode.nodeType === 30 /* ParseNodeType.Lambda */)) {
+            if ((innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 28 /* ParseNodeType.Function */ ||
+                (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 30 /* ParseNodeType.Lambda */ ||
+                (innerScopeNode === null || innerScopeNode === void 0 ? void 0 : innerScopeNode.nodeType) === 10 /* ParseNodeType.Class */) {
                 const innerScopeCodeFlowNode = AnalyzerNodeInfo.getFlowNode(innerScopeNode);
                 if (innerScopeCodeFlowNode) {
                     // See if any of the assignments of the symbol are reachable
@@ -3624,9 +3618,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const getAttrSymbol = types_1.ModuleType.getField(baseType, '__getattr__');
                         if (getAttrSymbol) {
                             const isModuleGetAttrSupported = fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_7 ||
-                                getAttrSymbol
-                                    .getDeclarations()
-                                    .some((decl) => decl.path.toLowerCase().endsWith('.pyi'));
+                                getAttrSymbol.getDeclarations().some((decl) => decl.uri.hasExtension('.pyi'));
                             if (isModuleGetAttrSupported) {
                                 const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                                 if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
@@ -5706,9 +5698,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addError(localize_1.Localizer.Diagnostic.superCallArgCount(), node.arguments[2]);
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node);
-        const enclosingClass = enclosingFunction
-            ? ParseTreeUtils.getEnclosingClass(enclosingFunction, /* stopAtFunction */ true)
-            : undefined;
+        const enclosingClass = enclosingFunction ? ParseTreeUtils.getEnclosingClass(enclosingFunction) : undefined;
         const enclosingClassType = enclosingClass ? (_a = getTypeOfClass(enclosingClass)) === null || _a === void 0 ? void 0 : _a.classType : undefined;
         // Determine which class the "super" call is applied to. If
         // there is no first argument, then the class is implicit.
@@ -5771,6 +5761,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (reportError) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
+                return { type: types_1.UnknownType.create() };
             }
         }
         else if (enclosingClassType) {
@@ -5838,34 +5829,77 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const lookupResults = bindToType
                 ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* MemberAccessFlags.Default */, effectiveTargetClass)
                 : undefined;
+            let resultType;
             if (lookupResults && (0, types_1.isInstantiableClass)(lookupResults.classType)) {
-                return {
-                    type: resultIsInstance
-                        ? types_1.ClassType.cloneAsInstance(lookupResults.classType)
-                        : lookupResults.classType,
-                    bindToSelfType: bindToType
-                        ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
-                        : undefined,
-                };
+                resultType = lookupResults.classType;
+            }
+            else if (effectiveTargetClass &&
+                !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
+                !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass) &&
+                objectType &&
+                (0, types_1.isClassInstance)(objectType)) {
+                resultType = types_1.ClassType.cloneAsInstantiable(objectType);
             }
+            else {
+                resultType = types_1.UnknownType.create();
+            }
+            return {
+                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType) : resultType,
+                bindToSelfType: bindToType
+                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
+                    : undefined,
+            };
         }
-        // If the lookup failed, try to return the first base class. An error
-        // will be reported by the member lookup logic at a later time.
+        // Handle the super() call when used outside of a member access expression.
         if ((0, types_1.isInstantiableClass)(targetClassType)) {
-            // If the class derives from one or more unknown classes,
-            // return unknown here to prevent spurious errors.
-            if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
-                return { type: types_1.UnknownType.create() };
-            }
-            const baseClasses = targetClassType.details.baseClasses;
-            if (baseClasses.length > 0) {
-                const baseClassType = baseClasses[0];
-                if ((0, types_1.isInstantiableClass)(baseClassType)) {
+            // We don't know which member is going to be accessed, so we cannot
+            // deterministically determine the correct type in this case. We'll
+            // use a heuristic that produces the "correct" (desired) behavior in
+            // most cases. If there's a bindToType and the targetClassType is one
+            // of the base classes of the bindToType, we'll return the next base
+            // class.
+            if (bindToType) {
+                let nextBaseClassType;
+                if (types_1.ClassType.isSameGenericClass(bindToType, targetClassType)) {
+                    if (bindToType.details.baseClasses.length > 0) {
+                        nextBaseClassType = bindToType.details.baseClasses[0];
+                    }
+                }
+                else {
+                    const baseClassIndex = bindToType.details.baseClasses.findIndex((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isSameGenericClass(baseClass, targetClassType));
+                    if (baseClassIndex >= 0 && baseClassIndex < bindToType.details.baseClasses.length - 1) {
+                        nextBaseClassType = bindToType.details.baseClasses[baseClassIndex + 1];
+                    }
+                }
+                if (nextBaseClassType) {
+                    if ((0, types_1.isInstantiableClass)(nextBaseClassType)) {
+                        nextBaseClassType = (0, typeUtils_1.specializeForBaseClass)(bindToType, nextBaseClassType);
+                    }
+                    return { type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(nextBaseClassType) : nextBaseClassType };
+                }
+                // There's not much we can say about the type. Simply return object or type.
+                if (objectType && (0, types_1.isClassInstance)(objectType) && typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
                     return {
-                        type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
+                        type: resultIsInstance ? objectType : (0, typeUtils_1.convertToInstance)(typeClassType),
                     };
                 }
             }
+            else {
+                // If the class derives from one or more unknown classes,
+                // return unknown here to prevent spurious errors.
+                if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
+                    return { type: types_1.UnknownType.create() };
+                }
+                const baseClasses = targetClassType.details.baseClasses;
+                if (baseClasses.length > 0) {
+                    const baseClassType = baseClasses[0];
+                    if ((0, types_1.isInstantiableClass)(baseClassType)) {
+                        return {
+                            type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
+                        };
+                    }
+                }
+            }
         }
         return { type: types_1.UnknownType.create() };
     }
@@ -6183,7 +6217,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const diagnostic = addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }), errorNode);
                 const overrideDecl = bestMatch.overload.details.declaration;
                 if (diagnostic && overrideDecl) {
-                    diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.path, overrideDecl.range);
+                    diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
                 }
             }
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
@@ -6663,7 +6697,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     newClassName = firstArgType.literalValue;
                 }
             }
-            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).filePath, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
+            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
             newClassType.details.baseClasses.push(getBuiltInType(errorNode, 'object'));
             newClassType.details.effectiveMetaclass = expandedCallType;
             (0, typeUtils_1.computeMroLinearization)(newClassType);
@@ -7611,7 +7645,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
         let effectiveExpectedType = inferenceContext.expectedType;
-        let effectiveFlags = 0 /* AssignTypeFlags.Default */;
+        let effectiveFlags = 1024 /* AssignTypeFlags.PopulatingExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(effectiveExpectedType, /* includeTypeArgs */ true)) {
             effectiveFlags |= 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
         }
@@ -7623,7 +7657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeVarContextCopy = typeVarContext.clone();
                 assignType(effectiveReturnType, effectiveExpectedType, 
                 /* diag */ undefined, typeVarContextCopy, 
-                /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* AssignTypeFlags.PopulatingExpectedType */);
+                /* srcTypeVarContext */ undefined, effectiveFlags);
                 const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, signatureTracker, skipUnknownArgCheck);
                 if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
                     effectiveExpectedType = undefined;
@@ -7669,6 +7703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
                             unknownIfNotFound: true,
                         });
+                        effectiveFlags |= 2048 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
                     }
                 }
             }
@@ -7684,7 +7719,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes, errorNode.start);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
-            /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* AssignTypeFlags.PopulatingExpectedType */);
+            /* srcTypeVarContext */ undefined, effectiveFlags);
         }
         return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
     }
@@ -8751,7 +8786,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
         /* isPep695Syntax */ false, 
-        /* typeParamNodes */ undefined, () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []);
+        /* typeParamNodes */ undefined, () => typeParameters);
     }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* ParseNodeType.Constant */) {
@@ -8819,7 +8854,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
         classFlags |= 4096 /* ClassTypeFlags.Final */;
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
         (0, typeUtils_1.computeMroLinearization)(classType);
@@ -8866,7 +8901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
@@ -10656,7 +10691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, typeParameters, typeParamNodes) {
+    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, isPep695TypeVarType, typeParameters, typeParamNodes) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -10701,24 +10736,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: variadics.map((v) => `"${v.details.name}"`).join(', '),
             }), errorNode);
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* TypeVarScopeType.Class */);
-        if (boundTypeVars.length > 0) {
-            addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
-                names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
-            }), errorNode);
+        if (!isPep695Syntax && !isPep695TypeVarType) {
+            const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* TypeVarScopeType.Class */);
+            if (boundTypeVars.length > 0) {
+                addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
+                    names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
+                }), errorNode);
+            }
         }
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
         const typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
         // All PEP 695 type aliases are special forms because they are
         // TypeAliasType objects at runtime.
-        if (isPep695Syntax) {
+        if (isPep695Syntax || isPep695TypeVarType) {
             typeAlias.flags |= 8 /* TypeFlags.SpecialForm */;
         }
         return typeAlias;
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        let specialClassType = types_1.ClassType.createInstantiable(assignedName, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, assignedName), fileInfo.moduleName, fileInfo.filePath, 1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */, 
+        let specialClassType = types_1.ClassType.createInstantiable(assignedName, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, assignedName), fileInfo.moduleName, fileInfo.fileUri, 1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */, 
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
@@ -10967,7 +11004,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
                         // If this is a type alias, record its name based on the assignment target.
                         rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
-                        /* isPep695Syntax */ false);
+                        /* isPep695Syntax */ false, 
+                        /* isPep695TypeVarType */ false);
                         (0, debug_1.assert)(typeAliasTypeVar !== undefined);
                         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
@@ -11024,11 +11062,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         return getTypeOfTypeAliasCommon(node, node.name, node.expression, 
         /* isPep695Syntax */ true, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
-            let typeParameters = [];
             if (node.typeParameters) {
-                typeParameters = evaluateTypeParameterList(node.typeParameters);
+                return evaluateTypeParameterList(node.typeParameters);
             }
-            return typeParameters;
+            return undefined;
         });
     }
     // This function is common to the handling of "type" statements and explicit
@@ -11067,7 +11104,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, typeParameters, typeParamNodes);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, 
+        /* isPep695TypeVarType */ true, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
                 name: nameNode.value,
@@ -11128,7 +11166,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (fileInfo.isStubFile) {
             classFlags |= 8388608 /* ClassTypeFlags.DefinedInStub */;
         }
-        const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.filePath, classFlags, 
+        const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, 
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.suite.statements));
@@ -11669,7 +11707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Replace all of the type parameters with invariant TypeVars.
         const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
         const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
-        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', '', 0, 0, undefined, undefined);
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
         updatedTypeParams.forEach((param, paramIndex) => {
             // Skip variadics and ParamSpecs.
             if (param.details.isVariadic || param.details.isParamSpec) {
@@ -11952,7 +11990,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (diag && initSubclassDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.initSubclassLocation().format({
                                 name: printType((0, typeUtils_1.convertToInstance)(initSubclassMethodInfo.classType)),
-                            }), initSubclassDecl.path, initSubclassDecl.range);
+                            }), initSubclassDecl.uri, initSubclassDecl.range);
                         }
                     }
                 }
@@ -12981,7 +13019,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, debug_1.assert)(!parentNode.isWildcardImport);
             const importInfo = AnalyzerNodeInfo.getImportInfo(parentNode.module);
             if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
-                const resolvedPath = importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1];
+                const resolvedPath = importInfo.resolvedUris[importInfo.resolvedUris.length - 1];
                 const importLookupInfo = importLookup(resolvedPath);
                 let reportError = false;
                 // If we were able to resolve the import, report the error as
@@ -13001,7 +13039,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                else if (!resolvedPath) {
+                else if (resolvedPath.isEmpty()) {
                     // This corresponds to the "from . import a" form.
                     reportError = true;
                 }
@@ -14404,13 +14442,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (namePartIndex >= 0 &&
                 importInfo &&
                 !importInfo.isNativeLib &&
-                namePartIndex < importInfo.resolvedPaths.length) {
-                if (importInfo.resolvedPaths[namePartIndex]) {
+                namePartIndex < importInfo.resolvedUris.length) {
+                if (importInfo.resolvedUris[namePartIndex]) {
                     evaluateTypesForStatement(node);
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(importInfo.resolvedPaths[namePartIndex]));
+                    declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -14723,8 +14761,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
         }
         function applyLoaderActionsToModuleType(moduleType, loaderActions, importLookup) {
-            if (loaderActions.path && loaderActions.loadSymbolsFromPath) {
-                const lookupResults = importLookup(loaderActions.path);
+            if (!loaderActions.uri.isEmpty() && loaderActions.loadSymbolsFromPath) {
+                const lookupResults = importLookup(loaderActions.uri);
                 if (lookupResults) {
                     moduleType.fields = lookupResults.symbolTable;
                     moduleType.docString = lookupResults.docString;
@@ -14747,7 +14785,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else {
                         const moduleName = moduleType.moduleName ? moduleType.moduleName + '.' + name : '';
-                        const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.path);
+                        const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
                         symbolType = applyLoaderActionsToModuleType(importedModuleType, implicitImport, importLookup);
                     }
                     const importedModuleSymbol = symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, symbolType);
@@ -14762,7 +14800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (resolvedDecl.type === 8 /* DeclarationType.Alias */) {
             // Build a module type that corresponds to the declaration and
             // its associated loader actions.
-            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.path);
+            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
             if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
                 return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
             }
@@ -14856,7 +14894,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // (but not an ellipsis).
                 if (isLegalImplicitTypeAliasType(inferredType)) {
                     inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node, 
-                    /* isPep695Syntax */ false);
+                    /* isPep695Syntax */ false, 
+                    /* isPep695TypeVarType */ false);
                     isUnambiguousType = true;
                 }
             }
@@ -15760,11 +15799,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // the length of the src type arguments list if the dest or source contain
     // entries with indeterminate length or variadic entries. It returns true
     // if the source is potentially compatible with the dest type, false otherwise.
-    function adjustSrcTupleTypeArgs(destTypeArgs, srcTypeArgs) {
-        const destUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
+    function adjustTupleTypeArgs(destTypeArgs, srcTypeArgs, flags) {
+        const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
+        const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
         // If the src contains an unbounded type but the dest does not, it's incompatible.
-        if (srcUnboundedIndex >= 0 && destUnboundedIndex < 0) {
+        if (srcUnboundedIndex >= 0 && destUnboundedOrVariadicIndex < 0) {
             return false;
         }
         if (srcUnboundedIndex >= 0) {
@@ -15782,36 +15822,64 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         while (destTypeArgs.length > srcTypeArgs.length && destTypeArgs[destTypeArgs.length - 1].isOptional) {
             destTypeArgs.splice(destTypeArgs.length - 1, 1);
         }
-        const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
-        if (destUnboundedIndex >= 0 && srcArgsToCapture >= 0) {
-            // If the dest contains a variadic element, determine which source
-            // args map to this element and package them up into an unpacked tuple.
-            if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedIndex].type)) {
-                if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    const removedArgs = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture);
+        if (srcVariadicIndex >= 0) {
+            const destArgsToCapture = destTypeArgs.length - srcTypeArgs.length + 1;
+            // If we're doing reverse type mappings and the source contains a variadic
+            // TypeVar, we need to adjust the dest so the reverse type mapping assignment
+            // can be performed.
+            if (destArgsToCapture >= 0 && (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
+                // If the only removed arg from the dest type args is itself a variadic,
+                // don't bother adjusting it.
+                const skipAdjustment = destArgsToCapture === 1 && (0, types_1.isVariadicTypeVar)(destTypeArgs[srcVariadicIndex].type);
+                if (!skipAdjustment && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    const removedArgs = destTypeArgs.splice(srcVariadicIndex, destArgsToCapture);
                     // Package up the remaining type arguments into a tuple object.
                     const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
                         return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
                     }), 
                     /* isTypeArgumentExplicit */ true, 
                     /* isUnpackedTuple */ true));
-                    srcTypeArgs.splice(destUnboundedIndex, 0, {
+                    destTypeArgs.splice(srcVariadicIndex, 0, {
                         type: variadicTuple,
                         isUnbounded: false,
                     });
                 }
             }
-            else {
-                const removedArgTypes = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture).map((t) => {
-                    if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
-                        return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+        }
+        else {
+            const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
+            if (destUnboundedOrVariadicIndex >= 0 && srcArgsToCapture >= 0) {
+                // If the dest contains a variadic element, determine which source
+                // args map to this element and package them up into an unpacked tuple.
+                if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
+                    if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                        const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
+                        // Package up the remaining type arguments into a tuple object.
+                        const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
+                            return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                        }), 
+                        /* isTypeArgumentExplicit */ true, 
+                        /* isUnpackedTuple */ true));
+                        srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                            type: variadicTuple,
+                            isUnbounded: false,
+                        });
                     }
-                    return t.type;
-                });
-                srcTypeArgs.splice(destUnboundedIndex, 0, {
-                    type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
-                    isUnbounded: false,
-                });
+                }
+                else {
+                    const removedArgTypes = srcTypeArgs
+                        .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
+                        .map((t) => {
+                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
+                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                        }
+                        return t.type;
+                    });
+                    srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                        type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                        isUnbounded: false,
+                    });
+                }
             }
         }
         return destTypeArgs.length === srcTypeArgs.length;
@@ -15820,8 +15888,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
         const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
-        const reverseMapping = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
-        if (adjustSrcTupleTypeArgs(reverseMapping ? srcTypeArgs : destTypeArgs, reverseMapping ? destTypeArgs : srcTypeArgs)) {
+        if (adjustTupleTypeArgs(destTypeArgs, srcTypeArgs, flags)) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                 if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
@@ -16021,6 +16088,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 else if (types_1.ClassType.isBuiltIn(destType, 'list')) {
                                     childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionList());
                                 }
+                                else if (types_1.ClassType.isBuiltIn(destType, 'set')) {
+                                    childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.invariantSuggestionSet());
+                                }
                             }
                         }
                         else {
@@ -16337,7 +16407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // PEP 544 says that if the dest type is a type[Proto] class,
                 // the source must be a "concrete" (non-protocol) class.
                 if (types_1.ClassType.isProtocolClass(destType) &&
-                    (flags & 4096 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
+                    (flags & 8192 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
                     if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.includeSubclasses) {
@@ -18249,7 +18319,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (!assignType(memberTypeFirstParamType, firstParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), typeVarContext, 
-            /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
+            /* srcTypeVarContext */ undefined, 4096 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {