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

package/dist/analyzer/dataClasses.js

@@ -10,7 +10,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -51,13 +55,13 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
     var _a;
     (0, debug_1.assert)(types_1.ClassType.isDataClass(classType));
     const classTypeVar = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ true);
-    const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
+    const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* FunctionTypeFlags.ConstructorMethod */);
     const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
     // Override `__new__` because some dataclasses (such as those that are
     // created by subclassing from NamedTuple) may have their own custom
     // __new__ that requires overriding.
     types_1.FunctionType.addParameter(newType, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'cls',
         type: classTypeVar,
         hasDeclaredType: true,
@@ -65,7 +69,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
     types_1.FunctionType.addDefaultParameters(newType);
     newType.details.declaredReturnType = (0, typeUtils_1.convertToInstance)(classTypeVar);
     const selfParam = {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'self',
         type: (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ false),
         hasDeclaredType: true,
@@ -87,7 +91,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
     const localEntryTypeEvaluator = [];
     let sawKeywordOnlySeparator = false;
     classType.details.fields.forEach((symbol, name) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (symbol.isIgnoredForProtocolMatch()) {
             return;
         }
@@ -98,11 +102,11 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
         }
         // Only variables (not functions, classes, etc.) are considered.
         const classVarDecl = symbol.getTypedDeclarations().find((decl) => {
-            if (decl.type !== 1 /* Variable */) {
+            if (decl.type !== 1 /* DeclarationType.Variable */) {
                 return false;
             }
             const container = (0, parseTreeUtils_1.getEnclosingClassOrFunction)(decl.node);
-            if (!container || container.nodeType !== 10 /* Class */) {
+            if (!container || container.nodeType !== 10 /* ParseNodeType.Class */) {
                 return false;
             }
             return true;
@@ -110,11 +114,11 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
         if (classVarDecl) {
             let statement = classVarDecl.node;
             while (statement) {
-                if (statement.nodeType === 3 /* Assignment */) {
+                if (statement.nodeType === 3 /* ParseNodeType.Assignment */) {
                     break;
                 }
-                if (statement.nodeType === 54 /* TypeAnnotation */) {
-                    if (((_a = statement.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+                if (statement.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+                    if (((_a = statement.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */) {
                         statement = statement.parent;
                     }
                     break;
@@ -132,9 +136,9 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
             let defaultValueExpression;
             let includeInInit = true;
             let converter;
-            if (statement.nodeType === 3 /* Assignment */) {
-                if (statement.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
-                    statement.leftExpression.valueExpression.nodeType === 38 /* Name */) {
+            if (statement.nodeType === 3 /* ParseNodeType.Assignment */) {
+                if (statement.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    statement.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */) {
                     variableNameNode = statement.leftExpression.valueExpression;
                     const assignmentStatement = statement;
                     variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.leftExpression.typeAnnotation, {
@@ -147,62 +151,29 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                 defaultValueExpression = statement.rightExpression;
                 // If the RHS of the assignment is assigning a field instance where the
                 // "init" parameter is set to false, do not include it in the init method.
-                if (statement.rightExpression.nodeType === 9 /* Call */) {
-                    const callTypeResult = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 16777218 /* CallBaseDefaults */);
+                if (statement.rightExpression.nodeType === 9 /* ParseNodeType.Call */) {
+                    const callTypeResult = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
                     const callType = callTypeResult.type;
                     if (isDataclassFieldConstructor(callType, ((_b = classType.details.dataClassBehaviors) === null || _b === void 0 ? void 0 : _b.fieldDescriptorNames) || [])) {
                         const initArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'init'; });
                         if (initArg && initArg.valueExpression) {
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                            const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(initArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
-                            if (value === false) {
-                                includeInInit = false;
-                            }
+                            includeInInit =
+                                (_c = (0, staticExpressions_1.evaluateStaticBoolExpression)(initArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants)) !== null && _c !== void 0 ? _c : includeInInit;
                         }
                         else {
-                            // See if the field constructor has an `init` parameter with
-                            // a default value.
-                            let callTarget;
-                            if ((0, types_1.isFunction)(callType)) {
-                                callTarget = callType;
-                            }
-                            else if ((0, types_1.isOverloadedFunction)(callType)) {
-                                callTarget = evaluator.getBestOverloadForArguments(statement.rightExpression, { type: callType, isIncomplete: callTypeResult.isIncomplete }, statement.rightExpression.arguments);
-                            }
-                            else if ((0, types_1.isInstantiableClass)(callType)) {
-                                const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluator, node.name, callType);
-                                if (initMethodResult) {
-                                    if ((0, types_1.isFunction)(initMethodResult.type)) {
-                                        callTarget = initMethodResult.type;
-                                    }
-                                    else if ((0, types_1.isOverloadedFunction)(initMethodResult.type)) {
-                                        callTarget = evaluator.getBestOverloadForArguments(statement.rightExpression, { type: initMethodResult.type }, statement.rightExpression.arguments);
-                                    }
-                                }
-                            }
-                            if (callTarget) {
-                                const initParam = callTarget.details.parameters.find((p) => p.name === 'init');
-                                if (initParam && initParam.defaultValueExpression && initParam.hasDeclaredType) {
-                                    if ((0, types_1.isClass)(initParam.type) &&
-                                        types_1.ClassType.isBuiltIn(initParam.type, 'bool') &&
-                                        (0, typeUtils_1.isLiteralType)(initParam.type)) {
-                                        if (initParam.type.literalValue === false) {
-                                            includeInInit = false;
-                                        }
-                                    }
-                                }
-                            }
+                            includeInInit =
+                                (_d = getDefaultArgValueForFieldSpecifier(evaluator, statement.rightExpression, callTypeResult, 'init')) !== null && _d !== void 0 ? _d : includeInInit;
                         }
                         const kwOnlyArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'kw_only'; });
                         if (kwOnlyArg && kwOnlyArg.valueExpression) {
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                            const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(kwOnlyArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
-                            if (value === false) {
-                                isKeywordOnly = false;
-                            }
-                            else if (value === true) {
-                                isKeywordOnly = true;
-                            }
+                            isKeywordOnly =
+                                (_e = (0, staticExpressions_1.evaluateStaticBoolExpression)(kwOnlyArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants)) !== null && _e !== void 0 ? _e : isKeywordOnly;
+                        }
+                        else {
+                            isKeywordOnly =
+                                (_f = getDefaultArgValueForFieldSpecifier(evaluator, statement.rightExpression, callTypeResult, 'kw_only')) !== null && _f !== void 0 ? _f : isKeywordOnly;
                         }
                         const defaultArg = statement.rightExpression.arguments.find((arg) => {
                             var _a, _b, _c;
@@ -230,8 +201,8 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                     }
                 }
             }
-            else if (statement.nodeType === 54 /* TypeAnnotation */) {
-                if (statement.valueExpression.nodeType === 38 /* Name */) {
+            else if (statement.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+                if (statement.valueExpression.nodeType === 38 /* ParseNodeType.Name */) {
                     variableNameNode = statement.valueExpression;
                     const annotationStatement = statement;
                     variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.typeAnnotation, {
@@ -255,7 +226,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                 // Don't include class vars. PEP 557 indicates that they shouldn't
                 // be considered data class entries.
                 const variableSymbol = classType.details.fields.get(variableName);
-                const isFinal = variableSymbol === null || variableSymbol === void 0 ? void 0 : variableSymbol.getDeclarations().some((decl) => decl.type === 1 /* Variable */ && decl.isFinal);
+                const isFinal = variableSymbol === null || variableSymbol === void 0 ? void 0 : variableSymbol.getDeclarations().some((decl) => decl.type === 1 /* DeclarationType.Variable */ && decl.isFinal);
                 if ((variableSymbol === null || variableSymbol === void 0 ? void 0 : variableSymbol.isClassVar()) && !isFinal) {
                     // If an ancestor class declared an instance variable but this dataclass
                     // declares a ClassVar, delete the older one from the full data class entries.
@@ -343,18 +314,18 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                 return;
             }
             const lastDecl = declarations[declarations.length - 1];
-            if (lastDecl.type !== 1 /* Variable */) {
+            if (lastDecl.type !== 1 /* DeclarationType.Variable */) {
                 return;
             }
             const statement = lastDecl.node.parent;
-            if (!statement || statement.nodeType !== 3 /* Assignment */) {
+            if (!statement || statement.nodeType !== 3 /* ParseNodeType.Assignment */) {
                 return;
             }
             // If the RHS of the assignment is assigning a field instance where the
             // "init" parameter is set to false, do not include it in the init method.
-            if (statement.rightExpression.nodeType === 9 /* Call */) {
-                const callType = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 16777218 /* CallBaseDefaults */).type;
-                if (isDataclassFieldConstructor(callType, ((_c = classType.details.dataClassBehaviors) === null || _c === void 0 ? void 0 : _c.fieldDescriptorNames) || [])) {
+            if (statement.rightExpression.nodeType === 9 /* ParseNodeType.Call */) {
+                const callType = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */).type;
+                if (isDataclassFieldConstructor(callType, ((_g = classType.details.dataClassBehaviors) === null || _g === void 0 ? void 0 : _g.fieldDescriptorNames) || [])) {
                     evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassFieldWithoutAnnotation(), statement.rightExpression);
                 }
             }
@@ -396,7 +367,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                         evaluator.addError(localize_1.Localizer.Diagnostic.dataClassFieldWithPrivateName(), entry.nameNode);
                     }
                     const functionParam = {
-                        category: 0 /* Simple */,
+                        category: 0 /* ParameterCategory.Simple */,
                         name: effectiveName,
                         hasDefault: entry.hasDefault,
                         defaultValueExpression: entry.defaultValueExpression,
@@ -413,7 +384,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
             });
             if (keywordOnlyParams.length > 0) {
                 types_1.FunctionType.addParameter(initType, {
-                    category: 1 /* ArgsList */,
+                    category: 1 /* ParameterCategory.ArgsList */,
                     type: types_1.AnyType.create(),
                 });
                 keywordOnlyParams.forEach((param) => {
@@ -421,8 +392,8 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                 });
             }
         }
-        symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
-        symbolTable.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
+        symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, initType));
+        symbolTable.set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
     }
     // Synthesize the __match_args__ class variable if it doesn't exist.
     const strType = evaluator.getBuiltInType(node, 'str');
@@ -443,13 +414,13 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
             return { type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(strType, name)), isUnbounded: false };
         });
         const matchArgsType = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, literalTypes));
-        symbolTable.set('__match_args__', symbol_1.Symbol.createWithType(4 /* ClassMember */, matchArgsType));
+        symbolTable.set('__match_args__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, matchArgsType));
     }
     const synthesizeComparisonMethod = (operator, paramType) => {
         const operatorMethod = types_1.FunctionType.createSynthesizedInstance(operator);
         types_1.FunctionType.addParameter(operatorMethod, selfParam);
         types_1.FunctionType.addParameter(operatorMethod, {
-            category: 0 /* Simple */,
+            category: 0 /* ParameterCategory.Simple */,
             name: 'other',
             type: paramType,
             hasDeclaredType: true,
@@ -457,7 +428,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
         operatorMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
         // If a method of this name already exists, don't override it.
         if (!symbolTable.get(operator)) {
-            symbolTable.set(operator, symbol_1.Symbol.createWithType(4 /* ClassMember */, operatorMethod));
+            symbolTable.set(operator, symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, operatorMethod));
         }
     };
     // Synthesize comparison operators.
@@ -484,17 +455,17 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
         const hashMethod = types_1.FunctionType.createSynthesizedInstance('__hash__');
         types_1.FunctionType.addParameter(hashMethod, selfParam);
         hashMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
-        symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 4096 /* IgnoredForOverrideChecks */, hashMethod));
+        symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 4096 /* SymbolFlags.IgnoredForOverrideChecks */, hashMethod));
     }
     else if (synthesizeHashNone && !skipSynthesizeHash) {
-        symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 4096 /* IgnoredForOverrideChecks */, evaluator.getNoneType()));
+        symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 4096 /* SymbolFlags.IgnoredForOverrideChecks */, evaluator.getNoneType()));
     }
     let dictType = evaluator.getBuiltInType(node, 'dict');
     if ((0, types_1.isInstantiableClass)(dictType)) {
         dictType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictType, [evaluator.getBuiltInObject(node, 'str'), types_1.AnyType.create()], 
         /* isTypeArgumentExplicit */ true));
     }
-    symbolTable.set('__dataclass_fields__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 128 /* ClassVar */, dictType));
+    symbolTable.set('__dataclass_fields__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 128 /* SymbolFlags.ClassVar */, dictType));
     if (types_1.ClassType.isGeneratedDataClassSlots(classType) && classType.details.localSlotsNames === undefined) {
         classType.details.localSlotsNames = localDataClassEntries.map((entry) => entry.name);
     }
@@ -505,7 +476,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
             iterableType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(iterableType, [evaluator.getBuiltInObject(node, 'str')], 
             /* isTypeArgumentExplicit */ true));
         }
-        symbolTable.set('__slots__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 128 /* ClassVar */, iterableType));
+        symbolTable.set('__slots__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 128 /* SymbolFlags.ClassVar */, iterableType));
     }
     // If this dataclass derived from a NamedTuple, update the NamedTuple with
     // the specialized entry types.
@@ -516,6 +487,50 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
     }
 }
 exports.synthesizeDataClassMethods = synthesizeDataClassMethods;
+// If a field specifier is used to define a field, it may define a default
+// argument value (either True or False) for a supported keyword parameter.
+// This function extracts that default value if present and returns it. If
+// it's not present, it returns undefined.
+function getDefaultArgValueForFieldSpecifier(evaluator, callNode, callTypeResult, paramName) {
+    const callType = callTypeResult.type;
+    let callTarget;
+    if ((0, types_1.isFunction)(callType)) {
+        callTarget = callType;
+    }
+    else if ((0, types_1.isOverloadedFunction)(callType)) {
+        callTarget = evaluator.getBestOverloadForArguments(callNode, { type: callType, isIncomplete: callTypeResult.isIncomplete }, callNode.arguments);
+    }
+    else if ((0, types_1.isInstantiableClass)(callType)) {
+        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluator, callNode, callType);
+        if (initMethodResult) {
+            if ((0, types_1.isFunction)(initMethodResult.type)) {
+                callTarget = initMethodResult.type;
+            }
+            else if ((0, types_1.isOverloadedFunction)(initMethodResult.type)) {
+                callTarget = evaluator.getBestOverloadForArguments(callNode, { type: initMethodResult.type }, callNode.arguments);
+            }
+        }
+    }
+    if (callTarget) {
+        const initParam = callTarget.details.parameters.find((p) => p.name === paramName);
+        if (initParam) {
+            // Is the parameter type a literal bool?
+            if (initParam.hasDeclaredType &&
+                (0, types_1.isClass)(initParam.type) &&
+                typeof initParam.type.literalValue === 'boolean') {
+                return initParam.type.literalValue;
+            }
+            // Is the default argument value a literal bool?
+            if (initParam.defaultValueExpression &&
+                initParam.defaultType &&
+                (0, types_1.isClass)(initParam.defaultType) &&
+                typeof initParam.defaultType.literalValue === 'boolean') {
+                return initParam.defaultType.literalValue;
+            }
+        }
+    }
+    return undefined;
+}
 // Validates converter and, if valid, returns its input type. If invalid,
 // fieldType is returned.
 function getConverterInputType(evaluator, converterNode, fieldType, fieldName) {
@@ -532,13 +547,13 @@ function getConverterInputType(evaluator, converterNode, fieldType, fieldName) {
     targetFunction.details.typeVarScopeId = typeVar.scopeId;
     targetFunction.details.declaredReturnType = fieldType;
     types_1.FunctionType.addParameter(targetFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: '__input',
         type: typeVar,
         hasDeclaredType: true,
     });
     types_1.FunctionType.addParameter(targetFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: '',
         type: types_1.UnknownType.create(),
     });
@@ -597,7 +612,7 @@ function getDescriptorForConverterField(evaluator, dataclassNode, converterNode,
     const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(dataclassNode);
     const typeMetaclass = evaluator.getBuiltInType(dataclassNode, 'type');
     const descriptorName = `__converterDescriptor_${fieldName}`;
-    const descriptorClass = types_1.ClassType.createInstantiable(descriptorName, (0, parseTreeUtils_1.getClassFullName)(converterNode, fileInfo.moduleName, descriptorName), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, (0, parseTreeUtils_1.getTypeSourceId)(converterNode), 
+    const descriptorClass = types_1.ClassType.createInstantiable(descriptorName, (0, parseTreeUtils_1.getClassFullName)(converterNode, fileInfo.moduleName, descriptorName), fileInfo.moduleName, fileInfo.filePath, 0 /* ClassTypeFlags.None */, (0, parseTreeUtils_1.getTypeSourceId)(converterNode), 
     /* declaredMetaclass */ undefined, (0, types_1.isInstantiableClass)(typeMetaclass) ? typeMetaclass : types_1.UnknownType.create());
     descriptorClass.details.baseClasses.push(evaluator.getBuiltInType(dataclassNode, 'object'));
     (0, typeUtils_1.computeMroLinearization)(descriptorClass);
@@ -605,55 +620,55 @@ function getDescriptorForConverterField(evaluator, dataclassNode, converterNode,
     const selfType = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(descriptorClass, /* isClsParam */ false);
     const setFunction = types_1.FunctionType.createSynthesizedInstance('__set__');
     types_1.FunctionType.addParameter(setFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'self',
         type: selfType,
         hasDeclaredType: true,
     });
     types_1.FunctionType.addParameter(setFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'obj',
         type: types_1.AnyType.create(),
         hasDeclaredType: true,
     });
     types_1.FunctionType.addParameter(setFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'value',
         type: setType,
         hasDeclaredType: true,
     });
     setFunction.details.declaredReturnType = evaluator.getNoneType();
-    const setSymbol = symbol_1.Symbol.createWithType(4 /* ClassMember */, setFunction);
+    const setSymbol = symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, setFunction);
     fields.set('__set__', setSymbol);
     const getFunction = types_1.FunctionType.createSynthesizedInstance('__get__');
     types_1.FunctionType.addParameter(getFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'self',
         type: selfType,
         hasDeclaredType: true,
     });
     types_1.FunctionType.addParameter(getFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'obj',
         type: types_1.AnyType.create(),
         hasDeclaredType: true,
     });
     types_1.FunctionType.addParameter(getFunction, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'objtype',
         type: types_1.AnyType.create(),
         hasDeclaredType: true,
     });
     getFunction.details.declaredReturnType = getType;
-    const getSymbol = symbol_1.Symbol.createWithType(4 /* ClassMember */, getFunction);
+    const getSymbol = symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, getFunction);
     fields.set('__get__', getSymbol);
-    return symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.ClassType.cloneAsInstance(descriptorClass));
+    return symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, types_1.ClassType.cloneAsInstance(descriptorClass));
 }
 // If the specified type is a descriptor — in particular, if it implements a
 // __set__ method, this method transforms the type into the input parameter
 // for the set method.
 function transformDescriptorType(evaluator, type) {
-    if (!(0, types_1.isClassInstance)(type)) {
+    if (!(0, types_1.isClassInstance)(type) || (0, typeUtils_1.isMetaclassInstance)(type)) {
         return type;
     }
     const setMethodType = evaluator.getBoundMagicMethod(type, '__set__');
@@ -732,7 +747,7 @@ function validateDataClassTransformDecorator(evaluator, node) {
     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
     // Parse the arguments to the call.
     node.arguments.forEach((arg) => {
-        if (!arg.name || arg.argumentCategory !== 0 /* Simple */) {
+        if (!arg.name || arg.argumentCategory !== 0 /* ArgumentCategory.Simple */) {
             evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformPositionalParam(), arg);
             return;
         }
@@ -853,28 +868,28 @@ function applyDataClassBehaviorOverrideValue(evaluator, errorNode, classType, ar
     switch (argName) {
         case 'order':
             if (argValue === true) {
-                classType.details.flags |= 64 /* SynthesizedDataClassOrder */;
+                classType.details.flags |= 64 /* ClassTypeFlags.SynthesizedDataClassOrder */;
             }
             else if (argValue === false) {
-                classType.details.flags &= ~64 /* SynthesizedDataClassOrder */;
+                classType.details.flags &= ~64 /* ClassTypeFlags.SynthesizedDataClassOrder */;
             }
             break;
         case 'kw_only':
             if (argValue === false) {
-                classType.details.flags &= ~2097152 /* DataClassKeywordOnlyParams */;
+                classType.details.flags &= ~2097152 /* ClassTypeFlags.DataClassKeywordOnlyParams */;
             }
             else if (argValue === true) {
-                classType.details.flags |= 2097152 /* DataClassKeywordOnlyParams */;
+                classType.details.flags |= 2097152 /* ClassTypeFlags.DataClassKeywordOnlyParams */;
             }
             break;
         case 'frozen': {
             let hasUnfrozenBaseClass = false;
             let hasFrozenBaseClass = false;
             if (argValue === false) {
-                classType.details.flags &= ~8 /* FrozenDataClass */;
+                classType.details.flags &= ~8 /* ClassTypeFlags.FrozenDataClass */;
             }
             else if (argValue === true) {
-                classType.details.flags |= 8 /* FrozenDataClass */;
+                classType.details.flags |= 8 /* ClassTypeFlags.FrozenDataClass */;
             }
             classType.details.baseClasses.forEach((baseClass) => {
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isDataClass(baseClass)) {
@@ -908,35 +923,35 @@ function applyDataClassBehaviorOverrideValue(evaluator, errorNode, classType, ar
         }
         case 'init':
             if (argValue === false) {
-                classType.details.flags |= 16 /* SkipSynthesizedDataClassInit */;
+                classType.details.flags |= 16 /* ClassTypeFlags.SkipSynthesizedDataClassInit */;
             }
             else if (argValue === true) {
-                classType.details.flags &= ~16 /* SkipSynthesizedDataClassInit */;
+                classType.details.flags &= ~16 /* ClassTypeFlags.SkipSynthesizedDataClassInit */;
             }
             break;
         case 'eq':
             if (argValue === false) {
-                classType.details.flags |= 32 /* SkipSynthesizedDataClassEq */;
+                classType.details.flags |= 32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */;
             }
             else if (argValue === true) {
-                classType.details.flags &= ~32 /* SkipSynthesizedDataClassEq */;
+                classType.details.flags &= ~32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */;
             }
             break;
         case 'slots':
             if (argValue === true) {
-                classType.details.flags |= 33554432 /* GenerateDataClassSlots */;
+                classType.details.flags |= 33554432 /* ClassTypeFlags.GenerateDataClassSlots */;
                 if (classType.details.localSlotsNames) {
                     evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassSlotsOverwrite(), errorNode);
                 }
             }
             else if (argValue === false) {
-                classType.details.flags &= ~33554432 /* GenerateDataClassSlots */;
+                classType.details.flags &= ~33554432 /* ClassTypeFlags.GenerateDataClassSlots */;
             }
             break;
         case 'hash':
         case 'unsafe_hash':
             if (argValue === true) {
-                classType.details.flags |= 67108864 /* SynthesizeDataClassUnsafeHash */;
+                classType.details.flags |= 67108864 /* ClassTypeFlags.SynthesizeDataClassUnsafeHash */;
             }
             break;
     }
@@ -960,18 +975,18 @@ function applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, a
 exports.applyDataClassClassBehaviorOverrides = applyDataClassClassBehaviorOverrides;
 function applyDataClassDefaultBehaviors(classType, defaultBehaviors) {
     classType.details.dataClassBehaviors = defaultBehaviors;
-    classType.details.flags |= 4 /* DataClass */;
+    classType.details.flags |= 4 /* ClassTypeFlags.DataClass */;
     if (defaultBehaviors.keywordOnlyParams) {
-        classType.details.flags |= 2097152 /* DataClassKeywordOnlyParams */;
+        classType.details.flags |= 2097152 /* ClassTypeFlags.DataClassKeywordOnlyParams */;
     }
     if (!defaultBehaviors.generateEq) {
-        classType.details.flags |= 32 /* SkipSynthesizedDataClassEq */;
+        classType.details.flags |= 32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */;
     }
     if (defaultBehaviors.generateOrder) {
-        classType.details.flags |= 64 /* SynthesizedDataClassOrder */;
+        classType.details.flags |= 64 /* ClassTypeFlags.SynthesizedDataClassOrder */;
     }
     if (defaultBehaviors.frozen) {
-        classType.details.flags |= 8 /* FrozenDataClass */;
+        classType.details.flags |= 8 /* ClassTypeFlags.FrozenDataClass */;
     }
 }
 exports.applyDataClassDefaultBehaviors = applyDataClassDefaultBehaviors;