@zzzen/pyright-internal 1.2.0-dev.20231224 → 1.2.0-dev.20240107

package/dist/analyzer/typeEvaluator.js

@@ -706,7 +706,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Make sure the resulting type is assignable to the expected type.
                 if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
                 /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 512 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
@@ -1398,15 +1398,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function getBoundMagicMethod(classType, memberName, selfType, recursionCount = 0) {
+    function getBoundMagicMethod(classType, memberName, selfType, diag, recursionCount = 0) {
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return undefined;
         }
         recursionCount++;
         const boundMethodResult = getTypeOfBoundMember(
         /* errorNode */ undefined, classType, memberName, 
-        /* usage */ undefined, 
-        /* diag */ undefined, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType, recursionCount);
+        /* usage */ undefined, diag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType, recursionCount);
         if (!boundMethodResult || boundMethodResult.typeErrors) {
             return undefined;
         }
@@ -1414,7 +1413,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
-            return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), recursionCount);
+            return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), diag, recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
             return (0, typeUtils_1.getUnknownTypeForCallable)();
@@ -1574,10 +1573,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const kwSeparatorIndex = functionType.details.parameters.findIndex((param) => param.category === 1 /* ParameterCategory.ArgsList */);
         // Add a keyword separator if necessary.
         if (kwSeparatorIndex < 0) {
-            types_1.FunctionType.addParameter(newFunction, {
-                category: 1 /* ParameterCategory.ArgsList */,
-                type: types_1.AnyType.create(),
-            });
+            types_1.FunctionType.addKeywordOnlyParameterSeparator(newFunction);
         }
         tdEntries.forEach((tdEntry, name) => {
             types_1.FunctionType.addParameter(newFunction, {
@@ -1738,6 +1734,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         specializedType.typeArguments.length > 0) {
                         return specializedType.typeArguments[0];
                     }
+                    return types_1.UnknownType.create();
                 }
             }
             if (errorNode) {
@@ -2970,9 +2967,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Verify that the name does not refer to a (non type alias) variable.
                     if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
                         let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
-                        if ((0, types_1.isClass)(type) && !type.includeSubclasses && !symbol.hasTypedDeclarations()) {
+                        if ((0, types_1.isClass)(type) &&
+                            !type.includeSubclasses &&
+                            !symbol.hasTypedDeclarations() &&
+                            types_1.ClassType.isValidTypeAliasClass(type)) {
                             // This check exempts class types that are created by calling
-                            // NewType, NamedTuple, and by invoking a metaclass directly.
+                            // NewType, NamedTuple, etc.
                             isAllowedTypeForVariable = true;
                         }
                         // Disable for assignments in the typings.pyi file, since it defines special forms.
@@ -4383,6 +4383,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return indexTypeResult;
     }
+    // If the list of type parameters includes a TypeVarTuple, we may need to adjust
+    // the supplied type arguments to map to the type parameter list.
     function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, errorNode) {
         const variadicIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         // Do we need to adjust the type arguments to map to a variadic type
@@ -4485,26 +4487,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ];
             }
         }
-        if (!typeParameters.some((typeVar) => typeVar.details.isVariadic && !typeVar.isVariadicInUnion)) {
-            let minTypeArgCount = typeParameters.length;
-            const firstNonDefaultParam = typeParameters.findIndex((param) => !!param.details.defaultType);
-            if (firstNonDefaultParam >= 0) {
-                minTypeArgCount = firstNonDefaultParam;
-            }
-            if (typeArgs.length > typeParameters.length) {
-                addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
-                    name: printType(baseType),
-                    expected: typeParameters.length,
-                    received: typeArgs.length,
-                }), typeArgs[typeParameters.length].node);
-            }
-            else if (typeArgs.length < minTypeArgCount) {
-                addError(localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
-                    name: printType(baseType),
-                    expected: typeParameters.length,
-                    received: typeArgs.length,
-                }), node.items[node.items.length - 1]);
-            }
+        let minTypeArgCount = typeParameters.length;
+        const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.defaultType);
+        if (firstDefaultParamIndex >= 0) {
+            minTypeArgCount = firstDefaultParamIndex;
+        }
+        if (typeArgs.length > typeParameters.length) {
+            addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                name: printType(baseType),
+                expected: typeParameters.length,
+                received: typeArgs.length,
+            }), typeArgs[typeParameters.length].node);
+        }
+        else if (typeArgs.length < minTypeArgCount) {
+            addError(localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
+                name: printType(baseType),
+                expected: typeParameters.length,
+                received: typeArgs.length,
+            }), node.items[node.items.length - 1]);
         }
         // Handle the mypy_extensions.FlexibleAlias type specially.
         if ((0, types_1.isInstantiableClass)(baseType) &&
@@ -4520,7 +4520,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeList = typeArgs[index].typeList;
                 if (typeList) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-                    types_1.TypeBase.setSpecialForm(functionType);
                     typeList.forEach((paramType, paramIndex) => {
                         types_1.FunctionType.addParameter(functionType, {
                             category: 0 /* ParameterCategory.Simple */,
@@ -4530,10 +4529,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             hasDeclaredType: true,
                         });
                     });
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                    if (typeList.length > 0) {
+                        types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                    }
+                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, types_1.isParamSpec)(typeArgType)) {
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, (0, typeUtils_1.convertToInstance)(typeArgType), diag, typeVarContext, 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, (0, typeUtils_1.convertToInstance)(typeArgType), diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isBuiltIn(typeArgType, 'Concatenate')) {
                     const concatTypeArgs = typeArgType.typeArguments;
@@ -4541,12 +4543,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (concatTypeArgs && concatTypeArgs.length > 0) {
                         concatTypeArgs.forEach((typeArg, index) => {
                             if (index === concatTypeArgs.length - 1) {
-                                // Add a position-only separator
-                                types_1.FunctionType.addParameter(functionType, {
-                                    category: 0 /* ParameterCategory.Simple */,
-                                    isNameSynthesized: false,
-                                    type: types_1.UnknownType.create(),
-                                });
+                                types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                                 if ((0, types_1.isParamSpec)(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
                                 }
@@ -4566,11 +4563,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         });
                     }
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
-                    types_1.TypeBase.setSpecialForm(functionType);
                     types_1.FunctionType.addDefaultParameters(functionType);
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
                 }
@@ -4606,7 +4602,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                if ((0, types_1.isUnpacked)(typeArgType) && !(0, types_1.isVariadicTypeVar)(param)) {
+                    const messageDiag = diag.createAddendum();
+                    messageDiag.addMessage(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument());
+                    messageDiag.addTextRange(typeArgs[index].node);
+                    typeArgType = types_1.UnknownType.create();
+                }
+                (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
             }
         });
         if (!diag.isEmpty()) {
@@ -4921,7 +4923,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), node.baseExpression);
             return { type: types_1.UnknownType.create() };
         }
-        // Handle the special case where the object is a Tuple and
+        // Handle the special case where the object is a tuple and
         // the index is a constant number (integer) or a slice with integer
         // start and end values. In these cases, we can determine
         // the exact type by indexing into the tuple type array.
@@ -4954,39 +4956,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if ((0, types_1.isClassInstance)(valueType) && types_1.ClassType.isBuiltIn(valueType, 'slice')) {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
-                if (tupleType && tupleType.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
-                    if (index0Expr.nodeType === 46 /* ParseNodeType.Slice */ && !index0Expr.stepValue) {
-                        // Create a local helper function to evaluate the slice parameters.
-                        const getSliceParameter = (expression, defaultValue) => {
-                            let value = defaultValue;
-                            if (expression) {
-                                const valType = getTypeOfExpression(expression).type;
-                                if ((0, types_1.isClassInstance)(valType) &&
-                                    types_1.ClassType.isBuiltIn(valType, 'int') &&
-                                    (0, typeUtils_1.isLiteralType)(valType) &&
-                                    typeof valType.literalValue === 'number') {
-                                    value = valType.literalValue;
-                                    if (value < 0) {
-                                        value = tupleType.tupleTypeArguments.length + value;
-                                    }
-                                }
-                                else {
-                                    value = -1;
-                                }
-                            }
-                            return value;
-                        };
-                        const startValue = getSliceParameter(index0Expr.startValue, 0);
-                        const endValue = getSliceParameter(index0Expr.endValue, tupleType.tupleTypeArguments.length);
-                        if (startValue >= 0 &&
-                            endValue > 0 &&
-                            endValue <= tupleType.tupleTypeArguments.length &&
-                            tupleClassType &&
-                            (0, types_1.isInstantiableClass)(tupleClassType)) {
-                            return {
-                                type: types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleType.tupleTypeArguments.slice(startValue, endValue))),
-                            };
-                        }
+                if (tupleType && index0Expr.nodeType === 46 /* ParseNodeType.Slice */) {
+                    const slicedTupleType = getSlicedTupleType(tupleType, index0Expr);
+                    if (slicedTupleType) {
+                        return { type: slicedTupleType };
                     }
                 }
             }
@@ -5106,6 +5079,51 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
+    // Given a tuple type and a slice expression, determines the resulting
+    // type if it can be determined. If not, it returns undefined.
+    function getSlicedTupleType(tupleType, sliceNode) {
+        // We don't handle step values.
+        if (sliceNode.stepValue || !tupleType.tupleTypeArguments) {
+            return undefined;
+        }
+        const tupleTypeArgs = tupleType.tupleTypeArguments;
+        const startValue = getTupleSliceParameter(sliceNode.startValue, 0, tupleTypeArgs);
+        const endValue = getTupleSliceParameter(sliceNode.endValue, tupleTypeArgs.length, tupleTypeArgs);
+        if (startValue === undefined || endValue === undefined || endValue < startValue) {
+            return undefined;
+        }
+        const slicedTypeArgs = tupleTypeArgs.slice(startValue, endValue);
+        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleType, slicedTypeArgs));
+    }
+    function getTupleSliceParameter(expression, defaultValue, tupleTypeArgs) {
+        let value = defaultValue;
+        if (expression) {
+            const valType = getTypeOfExpression(expression).type;
+            if (!(0, types_1.isClassInstance)(valType) || !types_1.ClassType.isBuiltIn(valType, 'int') || !(0, typeUtils_1.isLiteralType)(valType)) {
+                return undefined;
+            }
+            value = valType.literalValue;
+            const unboundedIndex = tupleTypeArgs.findIndex((typeArg) => typeArg.isUnbounded || (0, types_1.isVariadicTypeVar)(typeArg.type));
+            if (value < 0) {
+                value = tupleTypeArgs.length + value;
+                if (value < 0) {
+                    return undefined;
+                }
+                else if (unboundedIndex >= 0 && value <= unboundedIndex) {
+                    return undefined;
+                }
+            }
+            else {
+                if (value >= tupleTypeArgs.length) {
+                    return undefined;
+                }
+                else if (unboundedIndex >= 0 && value > unboundedIndex) {
+                    return undefined;
+                }
+            }
+        }
+        return value;
+    }
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags;
@@ -5121,7 +5139,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */ | 16 /* EvaluatorFlags.DisallowFinal */;
             }
-            adjFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */;
+            adjFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */ | 134217728 /* EvaluatorFlags.AllowConcatenate */;
         }
         // Create a local function that validates a single type argument.
         const getTypeArgTypeResult = (expr, argIndex) => {
@@ -5185,6 +5203,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             (0, typeUtils_1.isTupleClass)(typeResult.type)) {
                             typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
                         }
+                        else {
+                            addError(localize_1.Localizer.Diagnostic.unpackNotAllowed(), arg.valueExpression);
+                        }
                     }
                 }
                 if (arg.name) {
@@ -5251,6 +5272,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useTupleInstead());
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.tupleInAnnotation() + diag.getString(), node);
+            return { type: types_1.UnknownType.create() };
         }
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 &&
             node.expressions.length === 0 &&
@@ -5552,11 +5574,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (lambdaParams.length > 0) {
             const lastParam = lambdaParams[lambdaParams.length - 1];
             if (lastParam.category === 0 /* ParameterCategory.Simple */ && !lastParam.name) {
-                types_1.FunctionType.addParameter(expectedType, {
-                    category: 0 /* ParameterCategory.Simple */,
-                    name: '',
-                    type: types_1.UnknownType.create(),
-                });
+                types_1.FunctionType.addPositionOnlyParameterSeparator(expectedType);
             }
         }
         function getLambdaType() {
@@ -5843,9 +5861,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 resultType = types_1.UnknownType.create();
             }
             return {
-                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType) : resultType,
+                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType,
                 bindToSelfType: bindToType
-                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
+                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
+                    /* isClsParam */ false), bindToType.condition)
                     : undefined,
             };
         }
@@ -6437,18 +6456,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
         }
-        // Check for an attempt to invoke an abstract static or class method.
-        if (expandedCallType.boundToType &&
-            (0, types_1.isInstantiableClass)(expandedCallType.boundToType) &&
-            !expandedCallType.boundToType.includeSubclasses) {
-            if (types_1.FunctionType.isAbstractMethod(expandedCallType)) {
-                if (types_1.FunctionType.isStaticMethod(expandedCallType) || types_1.FunctionType.isClassMethod(expandedCallType)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
-                        method: expandedCallType.details.name,
-                    }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
-                }
-            }
-        }
         let effectiveTypeVarContext = typeVarContext;
         if (!effectiveTypeVarContext) {
             // If a typeVarContext wasn't provided by the caller, allocate one here.
@@ -6501,6 +6508,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedInitSelfType: functionResult.specializedInitSelfType,
         };
     }
+    function isMethodUnimplementedAbstract(functionType) {
+        let isAbstract = false;
+        // If the function is part of a protocol, it's automatically considered abstract
+        // unless it's located in a stub, in which case it must be explicitly marked as
+        // abstract.
+        if (types_1.FunctionType.isAbstractMethod(functionType)) {
+            isAbstract = true;
+        }
+        else if (functionType.details.methodClass &&
+            types_1.ClassType.isProtocolClass(functionType.details.methodClass) &&
+            functionType.details.declaration &&
+            !AnalyzerNodeInfo.getFileInfo(functionType.details.declaration.node).isStubFile) {
+            isAbstract = true;
+        }
+        if (!isAbstract) {
+            return false;
+        }
+        // Determine if the method is unimplemented by looking at whether its
+        // body contains a "trivial" implementation.
+        let implementation = functionType;
+        // If this is an overloaded method, consider the implementation.
+        if (functionType.overloaded) {
+            implementation = types_1.OverloadedFunctionType.getImplementation(functionType.overloaded);
+            // If there is no implementation and it's in a stub file, assume it's not abstract.
+            if (!implementation) {
+                return (functionType.details.declaration !== undefined &&
+                    !AnalyzerNodeInfo.getFileInfo(functionType.details.declaration.node).isStubFile);
+            }
+        }
+        if (!implementation.details.declaration) {
+            return false;
+        }
+        const decl = implementation.details.declaration;
+        return ParseTreeUtils.isSuiteEmpty(decl.node.suite) || methodAlwaysRaisesNotImplemented(decl);
+    }
     function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         // Handle the 'cast' call as a special case.
@@ -6542,8 +6584,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (types_1.ClassType.isBuiltIn(expandedCallType)) {
             const className = (_a = expandedCallType.aliasName) !== null && _a !== void 0 ? _a : expandedCallType.details.name;
-            // Handle the 'type' call specially.
-            if (expandedCallType.details.name === 'type') {
+            // Handle a call to a metaclass explicitly.
+            if ((0, typeUtils_1.isInstantiableMetaclass)(expandedCallType)) {
                 if (expandedCallType.typeArguments && expandedCallType.isTypeArgumentExplicit) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
                         type: printType(expandedCallType),
@@ -6552,9 +6594,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Validate the constructor arguments.
                 (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
-                if (argList.length === 1) {
-                    // The one-parameter form of "type" returns the class
-                    // for the specified object.
+                // The one-parameter form of "type" returns the class
+                // for the specified object.
+                if (expandedCallType.details.name === 'type' && argList.length === 1) {
                     const argType = getTypeOfArgument(argList[0]).type;
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
                         if ((0, types_1.isClassInstance)(subtype) ||
@@ -6570,9 +6612,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return { returnType };
                 }
                 if (argList.length >= 2) {
-                    // The two-parameter form of "type" returns a new class type
+                    // The two-parameter form of a call to a metaclass returns a new class
                     // built from the specified base types.
-                    return { returnType: createType(errorNode, argList) || types_1.AnyType.create() };
+                    return {
+                        returnType: createClassFromMetaclass(errorNode, argList, expandedCallType) || types_1.AnyType.create(),
+                    };
                 }
                 // If the parameter to type() is not statically known,
                 // fall back to Any.
@@ -7646,9 +7690,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
         let effectiveExpectedType = inferenceContext.expectedType;
-        let effectiveFlags = 1024 /* AssignTypeFlags.PopulatingExpectedType */;
+        let effectiveFlags = 2048 /* AssignTypeFlags.PopulatingExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(effectiveExpectedType, /* includeTypeArgs */ true)) {
-            effectiveFlags |= 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+            effectiveFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
         }
         // If the expected type is a union, we don't know which type is expected.
         // We may or may not be able to make use of the expected type. We'll evaluate
@@ -7704,7 +7748,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
                             unknownIfNotFound: true,
                         });
-                        effectiveFlags |= 2048 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
+                        effectiveFlags |= 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
                     }
                 }
             }
@@ -7732,6 +7776,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let specializedInitSelfType;
         let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
+        // Check for an attempt to invoke an unimplemented abstract method.
+        if (type.boundToType && !type.boundToType.includeSubclasses && isMethodUnimplementedAbstract(type)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
+                method: type.details.name,
+            }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
+        }
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
             // static method or a class method, it's possible that some of that class's
@@ -8598,6 +8648,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
                 }
             }
+            else {
+                addError(localize_1.Localizer.Diagnostic.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
+            }
         }
         return typeVar;
     }
@@ -8658,7 +8711,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getParamSpecDefaultType(node) {
         const functionType = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
-        types_1.TypeBase.setSpecialForm(functionType);
         if (node.nodeType === 18 /* ParseNodeType.Ellipsis */) {
             types_1.FunctionType.addDefaultParameters(functionType);
             return functionType;
@@ -8674,6 +8726,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: (0, typeUtils_1.convertToInstance)(typeResult.type),
                 });
             });
+            if (node.entries.length > 0) {
+                types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+            }
             // Update the type cache so we don't attempt to re-evaluate this node.
             // The type doesn't matter, so use Any.
             writeTypeCache(node, { type: types_1.AnyType.create() }, /* flags */ undefined);
@@ -8710,7 +8765,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (errorNode.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
             errorNode.parent.rightExpression !== errorNode ||
             errorNode.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
-            addError(localize_1.Localizer.Diagnostic.typeAliasTypeMustBeAssigned(), errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeMustBeAssigned(), errorNode);
             return undefined;
         }
         const nameNode = errorNode.parent.leftExpression;
@@ -8718,11 +8773,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
             const typeAliasName = firstArg.valueExpression.strings.map((s) => s.value).join('');
             if (typeAliasName !== nameNode.value) {
-                addError(localize_1.Localizer.Diagnostic.typeAliasTypeNameMismatch(), firstArg.valueExpression);
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeNameMismatch(), firstArg.valueExpression);
             }
         }
         else {
-            addError(localize_1.Localizer.Diagnostic.typeAliasTypeNameArg(), firstArg.valueExpression || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeNameArg(), firstArg.valueExpression || errorNode);
             return undefined;
         }
         let valueExpr;
@@ -8777,12 +8832,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
             if (!isTypeParamListValid) {
-                addError(localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
                 return undefined;
             }
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
-        /* isPep695Syntax */ false, 
+        /* isPep695Syntax */ true, 
         /* typeParamNodes */ undefined, () => typeParameters);
     }
     function getBooleanValue(node) {
@@ -8794,7 +8849,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
         }
-        addError(localize_1.Localizer.Diagnostic.expectedBoolLiteral(), node);
+        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.expectedBoolLiteral(), node);
         return false;
     }
     function getFunctionFullName(functionNode, moduleName, functionName) {
@@ -8814,7 +8869,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // in the Python specification: The static type checker will treat
     // the new type as if it were a subclass of the original type.
     function createNewType(errorNode, argList) {
-        var _a;
+        var _a, _b, _c;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         let className = '';
         if (argList.length !== 2) {
@@ -8831,26 +8886,36 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
             return undefined;
         }
+        if (((_b = errorNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */ &&
+            errorNode.parent.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
+            errorNode.parent.leftExpression.value !== className) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeNameMismatch(), errorNode.parent.leftExpression);
+            return undefined;
+        }
         let baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
         let isBaseClassAny = false;
         if ((0, types_1.isAnyOrUnknown)(baseClass)) {
             if (objectType && (0, types_1.isClassInstance)(objectType)) {
                 baseClass = types_1.ClassType.cloneAsInstantiable(objectType);
             }
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
             isBaseClassAny = true;
         }
         if (!(0, types_1.isInstantiableClass)(baseClass)) {
             addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
         }
-        if (types_1.ClassType.isProtocolClass(baseClass)) {
+        if (types_1.ClassType.isProtocolClass(baseClass) || types_1.ClassType.isTypedDictClass(baseClass)) {
             addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
         }
         else if (baseClass.literalValue !== undefined) {
             addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
         }
+        else if (types_1.ClassType.isNewTypeClass(baseClass)) {
+            addError(localize_1.Localizer.Diagnostic.newTypeNewTypeClass(), argList[1].node || errorNode);
+        }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
-        classFlags |= 4096 /* ClassTypeFlags.Final */;
+        classFlags |= 4096 /* ClassTypeFlags.Final */ | 268435456 /* ClassTypeFlags.NewTypeClass */ | 536870912 /* ClassTypeFlags.ValidTypeAliasClass */;
         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);
@@ -8887,7 +8952,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return classType;
     }
     // Implements the semantics of the multi-parameter variant of the "type" call.
-    function createType(errorNode, argList) {
+    function createClassFromMetaclass(errorNode, argList, metaclass) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         const arg0Type = getTypeOfArgument(argList[0]).type;
         if (!(0, types_1.isClassInstance)(arg0Type) || !types_1.ClassType.isBuiltIn(arg0Type, 'str')) {
@@ -8895,10 +8960,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const className = arg0Type.literalValue || '_';
         const arg1Type = getTypeOfArgument(argList[1]).type;
+        // TODO - properly handle case where tuple of base classes is provided.
         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.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 536870912 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
@@ -8936,14 +9002,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type: type !== null && type !== void 0 ? type : types_1.UnknownType.create() };
     }
-    function getTypeOfMagicMethodCall(objType, methodName, argList, errorNode, inferenceContext) {
+    function getTypeOfMagicMethodCall(objType, methodName, argList, errorNode, inferenceContext, diag) {
         let magicMethodSupported = true;
         // Create a helper lambda for object subtypes.
         const handleSubtype = (subtype) => {
             let magicMethodType;
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isClass)(concreteSubtype)) {
-                magicMethodType = getBoundMagicMethod(concreteSubtype, methodName, subtype);
+                magicMethodType = getBoundMagicMethod(concreteSubtype, methodName, subtype, diag);
             }
             if (magicMethodType) {
                 const functionArgs = argList.map((arg) => {
@@ -9283,7 +9349,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     mappingType = (0, typeUtils_1.selfSpecializeClass)(mappingType);
                     if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
                     /* diag */ undefined, mappingTypeVarContext, 
-                    /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
+                    /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
                         const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
                         const typeArgs = specializedMapping.typeArguments;
                         if (typeArgs && typeArgs.length >= 2) {
@@ -9711,11 +9777,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramsArePositionOnly &&
                     !isImplicitPositionOnlyParam &&
                     functionType.details.parameters.length > 0) {
-                    // Insert an implicit "position-only parameter" separator.
-                    types_1.FunctionType.addParameter(functionType, {
-                        category: 0 /* ParameterCategory.Simple */,
-                        type: types_1.UnknownType.create(),
-                    });
+                    types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                 }
                 if (!isImplicitPositionOnlyParam) {
                     paramsArePositionOnly = false;
@@ -9732,11 +9794,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addParameter(functionType, functionParam);
         });
         if (paramsArePositionOnly && functionType.details.parameters.length > 0) {
-            // Insert an implicit "position-only parameter" separator.
-            types_1.FunctionType.addParameter(functionType, {
-                category: 0 /* ParameterCategory.Simple */,
-                type: types_1.UnknownType.create(),
-            });
+            types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
         }
         let typeErrors = false;
         // If we're speculatively evaluating the lambda, create another speculative
@@ -10047,12 +10105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 });
                 if (typeList.length > 0) {
-                    // Add a positional-only separator to the end of the parameter list.
-                    types_1.FunctionType.addParameter(functionType, {
-                        category: 0 /* ParameterCategory.Simple */,
-                        isNameSynthesized: false,
-                        type: types_1.UnknownType.create(),
-                    });
+                    types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                 }
             }
             else if ((0, typeUtils_1.isEllipsisType)(typeArgs[0].type)) {
@@ -10068,12 +10121,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (concatTypeArgs && concatTypeArgs.length > 0) {
                         concatTypeArgs.forEach((typeArg, index) => {
                             if (index === concatTypeArgs.length - 1) {
-                                // Add a position-only separator
-                                types_1.FunctionType.addParameter(functionType, {
-                                    category: 0 /* ParameterCategory.Simple */,
-                                    isNameSynthesized: false,
-                                    type: types_1.UnknownType.create(),
-                                });
+                                types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                                 if ((0, types_1.isParamSpec)(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
                                 }
@@ -10308,14 +10356,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 name: classType.details.name,
             }), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
         }
-        const enclosingClass = ParseTreeUtils.getEnclosingClass(errorNode);
+        let enclosingClass = ParseTreeUtils.getEnclosingClass(errorNode);
+        // If `Self` appears anywhere outside of the class body (e.g. a decorator,
+        // base class list, metaclass argument, type parameter list), it is
+        // considered illegal.
+        if (enclosingClass && !ParseTreeUtils.isNodeContainedWithin(errorNode, enclosingClass.suite)) {
+            enclosingClass = undefined;
+        }
         const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
         if (!enclosingClassTypeResult) {
-            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ | 128 /* EvaluatorFlags.ExpectingInstantiableType */)) !== 0) {
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeContext(), errorNode);
             }
             return types_1.UnknownType.create();
         }
+        else if ((0, typeUtils_1.isInstantiableMetaclass)(enclosingClassTypeResult.classType)) {
+            // If `Self` appears within a metaclass, it is considered illegal.
+            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeMetaclass(), errorNode);
+            return types_1.UnknownType.create();
+        }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
         if (enclosingFunction) {
             const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
@@ -10452,7 +10511,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeArgs[0].type;
     }
-    function createConcatenateType(errorNode, classType, typeArgs) {
+    function createConcatenateType(errorNode, classType, typeArgs, flags) {
+        if ((flags & 134217728 /* EvaluatorFlags.AllowConcatenate */) === 0) {
+            addError(localize_1.Localizer.Diagnostic.concatenateContext(), errorNode);
+            return types_1.AnyType.create();
+        }
         if (!typeArgs || typeArgs.length === 0) {
             addError(localize_1.Localizer.Diagnostic.concatenateTypeArgsMissing(), errorNode);
         }
@@ -10485,6 +10548,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!typeArgs || typeArgs.length === 0) {
             return { type: types_1.AnyType.create() };
         }
+        if (typeArgs[0].typeList) {
+            addError(localize_1.Localizer.Diagnostic.typeArgListNotAllowed(), typeArgs[0].node);
+        }
         return {
             type: types_1.TypeBase.cloneForAnnotated(typeArgs[0].type),
             isReadOnly: typeArgs[0].isReadOnly,
@@ -10606,7 +10672,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Unpacks the index expression for a "Union[X, Y, Z]" type annotation.
     function createUnionType(classType, errorNode, typeArgs, flags) {
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         const types = [];
+        let allowSingleTypeArg = false;
         if (!typeArgs) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
@@ -10628,15 +10696,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // If this is an unpacked tuple, explode out the individual items.
             if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.tupleTypeArguments) {
-                typeArg.type.tupleTypeArguments.forEach((tupleTypeArg) => {
-                    types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
-                });
+                if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
+                    typeArg.type.tupleTypeArguments.forEach((tupleTypeArg) => {
+                        types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
+                    });
+                    allowSingleTypeArg = true;
+                }
+                else {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionUnpackedTuple(), errorNode);
+                    types.push(types_1.UnknownType.create());
+                }
             }
             else {
-                // If this is an unpacked TypeVar, note that it is in a union so we can differentiate
-                // between Unpack[Vs] and Union[Unpack[Vs]].
                 if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedVariadicTypeVar)(typeArgType)) {
-                    typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
+                    if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
+                        // If this is an unpacked TypeVar, note that it is in a union so we can
+                        // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
+                        typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
+                        allowSingleTypeArg = true;
+                    }
+                    else {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionUnpackedTypeVarTuple(), errorNode);
+                        typeArgType = types_1.UnknownType.create();
+                    }
                 }
                 types.push(typeArgType);
             }
@@ -10644,10 +10726,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Validate that we received at least two type arguments. One type argument
         // is allowed if it's an unpacked variadic type var or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
-        if (types.length === 1) {
-            if (!(0, types_1.isVariadicTypeVar)(types[0]) && !(0, types_1.isUnpacked)(types[0]) && !(0, typeUtils_1.isNoneInstance)(types[0])) {
-                addError(localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
-            }
+        if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
+            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
         }
         const unionType = (0, types_1.combineTypes)(types);
         if ((0, types_1.isUnion)(unionType)) {
@@ -11003,7 +11083,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // only if the evaluated type is an instantiable type.
                     if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
                         // If this is a type alias, record its name based on the assignment target.
-                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
+                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasNameNode, 
                         /* isPep695Syntax */ false, 
                         /* isPep695TypeVarType */ false);
                         (0, debug_1.assert)(typeAliasTypeVar !== undefined);
@@ -11094,17 +11174,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setSymbolResolutionPartialType(typeAliasSymbol.symbol, typeAliasDecl, typeAliasTypeVar);
         }
         const typeParameters = getTypeParamCallback();
-        typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
-        if (!isLegalTypeAliasExpressionForm(valueNode)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), valueNode);
-        }
-        const aliasTypeResult = getTypeOfExpressionExpectingType(valueNode, { allowForwardReference: true });
+        typeAliasTypeVar.details.recursiveTypeParameters = typeParameters || [];
+        const aliasTypeResult = getTypeOfExpressionExpectingType(valueNode, {
+            allowForwardReference: true,
+            enforceTypeAnnotationRules: true,
+        });
         let isIncomplete = false;
         let aliasType = aliasTypeResult.type;
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, 
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, nameNode, 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({
@@ -11363,6 +11443,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
+                else if (types_1.ClassType.isTypedDictClass(classType)) {
+                    if (arg.name.value === 'total') {
+                        // The "total" and "readonly" parameters apply only for TypedDict classes.
+                        // PEP 589 specifies that the parameter must be either True or False.
+                        const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                        if (constArgValue === undefined) {
+                            addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
+                        }
+                        else if (arg.name.value === 'total' && !constArgValue) {
+                            classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
+                        }
+                    }
+                    else {
+                        addError(localize_1.Localizer.Diagnostic.typedDictInitsubclassParameter().format({ name: arg.name.value }), arg);
+                    }
+                }
                 else if (arg.name.value === 'metaclass') {
                     if (metaclassNode) {
                         addError(localize_1.Localizer.Diagnostic.metaclassDuplicate(), arg);
@@ -11371,17 +11467,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         metaclassNode = arg.valueExpression;
                     }
                 }
-                else if (types_1.ClassType.isTypedDictClass(classType) && arg.name.value === 'total') {
-                    // The "total" and "readonly" parameters apply only for TypedDict classes.
-                    // PEP 589 specifies that the parameter must be either True or False.
-                    const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
-                    if (constArgValue === undefined) {
-                        addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
-                    }
-                    else if (arg.name.value === 'total' && !constArgValue) {
-                        classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
-                    }
-                }
                 else {
                     // Collect arguments that will be passed to the `__init_subclass__`
                     // method described in PEP 487.
@@ -12272,11 +12357,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramsArePositionOnly &&
                     !isImplicitPositionOnlyParam &&
                     functionType.details.parameters.length > firstNonClsSelfParamIndex) {
-                    // Insert an implicit "position-only parameter" separator.
-                    types_1.FunctionType.addParameter(functionType, {
-                        category: 0 /* ParameterCategory.Simple */,
-                        type: types_1.UnknownType.create(),
-                    });
+                    types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
                 }
                 if (!isImplicitPositionOnlyParam) {
                     paramsArePositionOnly = false;
@@ -12315,11 +12396,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (paramsArePositionOnly && functionType.details.parameters.length > firstNonClsSelfParamIndex) {
-            // Insert an implicit "position-only parameter" separator.
-            types_1.FunctionType.addParameter(functionType, {
-                category: 0 /* ParameterCategory.Simple */,
-                type: types_1.UnknownType.create(),
-            });
+            types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
         }
         // Update the types for the nodes associated with the parameters.
         paramTypes.forEach((paramType, index) => {
@@ -12915,7 +12992,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const additionalHelp = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isClass)(subtype)) {
                 let enterType = getTypeOfMagicMethodCall(subtype, enterMethodName, [], node.expression, 
-                /* inferenceContext */ undefined);
+                /* inferenceContext */ undefined, additionalHelp.createAddendum());
                 if (enterType) {
                     // For "async while", an implicit "await" is performed.
                     if (isAsync) {
@@ -13785,7 +13862,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return createAnnotatedType(errorNode, typeArgs);
                 }
                 case 'Concatenate': {
-                    return { type: createConcatenateType(errorNode, classType, typeArgs) };
+                    return { type: createConcatenateType(errorNode, classType, typeArgs, flags) };
                 }
                 case 'TypeGuard': {
                     return { type: createTypeGuardType(errorNode, classType, typeArgs, flags) };
@@ -13858,9 +13935,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const variadicTypeParamIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         if (typeArgs) {
             let minTypeArgCount = typeParameters.length;
-            const firstNonDefaultParam = typeParameters.findIndex((param) => !!param.details.defaultType);
-            if (firstNonDefaultParam >= 0) {
-                minTypeArgCount = firstNonDefaultParam;
+            const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.defaultType);
+            if (firstDefaultParamIndex >= 0) {
+                minTypeArgCount = firstDefaultParamIndex;
             }
             // Classes that accept inlined type dict type args allow only one.
             if (typeArgs[0].inlinedTypeDict) {
@@ -13958,7 +14035,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-                    types_1.TypeBase.setSpecialForm(functionType);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         types_1.FunctionType.addDefaultParameters(functionType);
                         functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
@@ -13976,6 +14052,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 hasDeclaredType: true,
                             });
                         });
+                        if (typeArg.typeList.length > 0) {
+                            types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                        }
                         typeArgTypes.push(functionType);
                         typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(functionType));
                         return;
@@ -14505,7 +14584,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             // Determine if this node is within a quoted type annotation.
             const isWithinTypeAnnotation = ParseTreeUtils.isWithinTypeAnnotation(node, !(0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node)));
-            const allowForwardReferences = isWithinTypeAnnotation || fileInfo.isStubFile;
+            // Determine if this is part of a "type" statement.
+            const isWithinTypeAliasStatement = !!ParseTreeUtils.getParentNodeOfType(node, 77 /* ParseNodeType.TypeAlias */);
+            const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
             let symbol;
             const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
             if (typeParamSymbol) {
@@ -15712,7 +15793,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function assignClassToSelf(destType, srcType, ignoreBaseClassVariance = true, recursionCount = 0) {
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         (0, debug_1.assert)(destType.details.typeParameters.length > 0);
-        const diag = new diagnostic_1.DiagnosticAddendum();
         const typeVarContext = new typeVarContext_1.TypeVarContext();
         let isAssignable = true;
         destType.details.fields.forEach((symbol, name) => {
@@ -15733,7 +15813,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 types_1.ClassType.isPropertyClass(destMemberType) &&
                 (0, types_1.isClassInstance)(srcMemberType) &&
                 types_1.ClassType.isPropertyClass(srcMemberType)) {
-                if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
+                if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, 
+                /* diag */ undefined, typeVarContext, 
                 /* selfTypeVarContext */ undefined, recursionCount)) {
                     isAssignable = false;
                 }
@@ -15752,7 +15833,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         flags |= 1 /* AssignTypeFlags.EnforceInvariance */;
                     }
                 }
-                if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
+                if (!assignType(destMemberType, srcMemberType, 
+                /* diag */ undefined, typeVarContext, 
                 /* srcTypeVarContext */ undefined, flags, recursionCount)) {
                     isAssignable = false;
                 }
@@ -16057,16 +16139,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let errorSource;
             let includeDiagAddendum = true;
             if (variance === 3 /* Variance.Covariant */) {
-                effectiveFlags = flags | 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                effectiveFlags = flags | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsCovariant;
             }
             else if (variance === 4 /* Variance.Contravariant */) {
                 effectiveFlags =
-                    (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                    (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsContravariant;
             }
             else {
-                effectiveFlags = flags | 1 /* AssignTypeFlags.EnforceInvariance */ | 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                effectiveFlags = flags | 1 /* AssignTypeFlags.EnforceInvariance */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsInvariant;
                 // Omit the diagnostic addendum for the invariant case because it's obvious
                 // why two types are not the same.
@@ -16189,7 +16271,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Strip flags we don't want to propagate to other calls.
         const originalFlags = flags;
-        flags &= ~64 /* AssignTypeFlags.AllowBoolTypeGuard */;
+        flags &= ~128 /* AssignTypeFlags.AllowBoolTypeGuard */;
         // Before performing any other checks, see if the dest type is a
         // TypeVar that we are attempting to match.
         if ((0, types_1.isTypeVar)(destType)) {
@@ -16414,7 +16496,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 & 8192 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
+                    (flags & 16384 /* AssignTypeFlags.IgnoreProtocolAssignmentCheck */) === 0) {
                     if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.includeSubclasses) {
@@ -16466,7 +16548,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (types_1.ClassType.isBuiltIn(destType, 'TypeGuard')) {
                 // All the source to be a "bool".
-                if ((originalFlags & 64 /* AssignTypeFlags.AllowBoolTypeGuard */) !== 0) {
+                if ((originalFlags & 128 /* AssignTypeFlags.AllowBoolTypeGuard */) !== 0) {
                     if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'bool')) {
                         return true;
                     }
@@ -16560,7 +16642,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClassInstance)(concreteSrcType)) {
                 const boundMethod = getBoundMagicMethod(concreteSrcType, '__call__', 
-                /* selfType */ undefined, recursionCount);
+                /* selfType */ undefined, 
+                /* diag */ undefined, recursionCount);
                 if (boundMethod) {
                     concreteSrcType = (0, typeUtils_1.removeParamSpecVariadicsFromSignature)(boundMethod);
                 }
@@ -16680,6 +16763,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Sort the subtypes so we have a deterministic order for unions.
         let sortedSrcTypes = (0, typeUtils_1.sortTypes)(srcType.subtypes);
+        let matchedSomeSubtypes = false;
         // Handle the case where the source and dest are both unions. Try
         // to eliminate as many exact type matches between the src and dest.
         if ((0, types_1.isUnion)(destType)) {
@@ -16706,6 +16790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const srcTypeIndex = remainingSrcSubtypes.findIndex((srcSubtype) => (0, types_1.isTypeSame)(srcSubtype, destSubtype, {}, recursionCount));
                     if (srcTypeIndex >= 0) {
                         remainingSrcSubtypes.splice(srcTypeIndex, 1);
+                        matchedSomeSubtypes = true;
                     }
                     else {
                         remainingDestSubtypes.push(destSubtype);
@@ -16743,7 +16828,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return false;
                 });
                 if (destTypeIndex >= 0) {
-                    if (!assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        // Note that we have matched at least one subtype indicating
+                        // there is at least some overlap.
+                        matchedSomeSubtypes = true;
+                    }
+                    else {
                         canUseFastPath = false;
                     }
                     remainingDestSubtypes.splice(destTypeIndex, 1);
@@ -16781,7 +16871,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     sortedSrcTypes = remainingSrcSubtypes;
                 }
                 else if (remainingSrcSubtypes.length === 0) {
-                    if ((flags & 1024 /* AssignTypeFlags.PopulatingExpectedType */) !== 0) {
+                    if ((flags & 2048 /* AssignTypeFlags.PopulatingExpectedType */) !== 0) {
                         // If we're populating an expected type, try not to leave
                         // any TypeVars unsolved. Assign the full type to the remaining
                         // dest TypeVars.
@@ -16804,6 +16894,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (canUseFastPath) {
                 return true;
             }
+            // If we're looking for type overlaps and at least one type was matched,
+            // consider it as assignable.
+            if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */) !== 0 && matchedSomeSubtypes) {
+                return true;
+            }
         }
         let isIncompatible = false;
         sortedSrcTypes.forEach((subtype) => {
@@ -16822,8 +16917,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncompatible = true;
                 }
             }
+            else {
+                matchedSomeSubtypes = true;
+            }
         }, /* sortSubtypes */ true);
         if (isIncompatible) {
+            // If we're looking for type overlaps and at least one type was matched,
+            // consider it as assignable.
+            if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */) !== 0 && matchedSomeSubtypes) {
+                return true;
+            }
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
             return false;
         }
@@ -17061,7 +17164,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const boundMethod = getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, recursionCount);
+        const boundMethod = getBoundMagicMethod(objType, '__call__', 
+        /* selfType */ undefined, 
+        /* diag */ undefined, recursionCount);
         if (boundMethod) {
             return (0, typeUtils_1.removeParamSpecVariadicsFromSignature)(boundMethod);
         }
@@ -17094,7 +17199,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Is an additional specialization step required?
         if (doSpecializationStep) {
             assignType(specializedSrcType, specializedDestType, 
-            /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */, recursionCount);
+            /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */, recursionCount);
             if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
                 specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext);
             }
@@ -17208,9 +17313,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function assignFunction(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         let canAssign = true;
-        const checkReturnType = (flags & 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
+        const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
         const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
-        flags &= ~32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */;
+        flags &= ~64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */;
         destType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(destType);
         srcType = (0, typeUtils_1.removeParamSpecVariadicsFromFunction)(srcType);
         const destParamDetails = (0, parameterUtils_1.getParameterListDetails)(destType);
@@ -17234,17 +17339,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const destParamType = destParam.type;
             const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : '';
             const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : '';
-            if (destParamName && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(destParamName) && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(srcParamName)) {
+            if (destParamName) {
                 const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
                 if (!isDestPositionalOnly &&
                     destParam.param.category !== 1 /* ParameterCategory.ArgsList */ &&
-                    srcParam.param.category !== 1 /* ParameterCategory.ArgsList */ &&
-                    destParamName !== srcParamName) {
-                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamName().format({
-                        srcName: srcParamName,
-                        destName: destParamName,
-                    }));
-                    canAssign = false;
+                    srcParam.param.category !== 1 /* ParameterCategory.ArgsList */) {
+                    if (srcParam.source === parameterUtils_1.ParameterSource.PositionOnly) {
+                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamPositionOnly().format({
+                            name: destParamName,
+                        }));
+                        canAssign = false;
+                    }
+                    else if (destParamName !== srcParamName) {
+                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamName().format({
+                            srcName: srcParamName,
+                            destName: destParamName,
+                        }));
+                        canAssign = false;
+                    }
                 }
             }
             if (!!destParam.param.hasDefault &&
@@ -17269,7 +17381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!assignFunctionParameter(destParamType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                 // Handle the special case where the source parameter is a synthesized
                 // TypeVar for "self" or "cls".
-                if ((flags & 256 /* AssignTypeFlags.SkipSelfClsTypeCheck */) === 0 ||
+                if ((flags & 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */) === 0 ||
                     !(0, types_1.isTypeVar)(srcParamType) ||
                     !srcParamType.details.isSynthesized) {
                     canAssign = false;
@@ -17599,7 +17711,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // solver to retain literals.
                 if (srcType.details.declaredReturnType &&
                     (0, typeUtils_1.containsLiteralType)(srcType.details.declaredReturnType, /* includeTypeArgs */ true)) {
-                    effectiveFlags |= 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                    effectiveFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 }
                 if ((0, types_1.isNever)(srcReturnType)) {
                     // We'll allow any function that returns NoReturn to match any
@@ -18343,7 +18455,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (!assignType(memberTypeFirstParamType, firstParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), typeVarContext, 
-            /* srcTypeVarContext */ undefined, 4096 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
+            /* srcTypeVarContext */ undefined, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {
@@ -18415,6 +18527,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 31 /* ParseNodeType.List */:
             case 45 /* ParseNodeType.Set */:
                 return false;
+            case 7 /* ParseNodeType.BinaryOperation */:
+                return (node.operator === 6 /* OperatorType.BitwiseOr */ &&
+                    isLegalTypeAliasExpressionForm(node.leftExpression) &&
+                    isLegalTypeAliasExpressionForm(node.rightExpression));
+            case 24 /* ParseNodeType.Index */:
+                return isLegalTypeAliasExpressionForm(node.baseExpression);
+            case 35 /* ParseNodeType.MemberAccess */:
+                return isLegalTypeAliasExpressionForm(node.leftExpression);
         }
         return true;
     }