@zzzen/pyright-internal 1.2.0-dev.20230813 → 1.2.0-dev.20230820

package/dist/analyzer/dataClasses.js

@@ -86,270 +86,276 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
     }
     const localEntryTypeEvaluator = [];
     let sawKeywordOnlySeparator = false;
-    classType.details.fields.forEach((symbol) => {
+    classType.details.fields.forEach((symbol, name) => {
         var _a, _b, _c;
-        if (!symbol.isIgnoredForProtocolMatch()) {
-            // Only variables (not functions, classes, etc.) are considered.
-            const classVarDecl = symbol.getTypedDeclarations().find((decl) => {
-                if (decl.type !== 1 /* Variable */) {
-                    return false;
-                }
-                const container = (0, parseTreeUtils_1.getEnclosingClassOrFunction)(decl.node);
-                if (!container || container.nodeType !== 10 /* Class */) {
-                    return false;
+        if (symbol.isIgnoredForProtocolMatch()) {
+            return;
+        }
+        // Apparently, `__hash__` is special-cased in a dataclass. I can't find
+        // this in the spec, but the runtime seems to treat is specially.
+        if (name === '__hash__') {
+            return;
+        }
+        // Only variables (not functions, classes, etc.) are considered.
+        const classVarDecl = symbol.getTypedDeclarations().find((decl) => {
+            if (decl.type !== 1 /* Variable */) {
+                return false;
+            }
+            const container = (0, parseTreeUtils_1.getEnclosingClassOrFunction)(decl.node);
+            if (!container || container.nodeType !== 10 /* Class */) {
+                return false;
+            }
+            return true;
+        });
+        if (classVarDecl) {
+            let statement = classVarDecl.node;
+            while (statement) {
+                if (statement.nodeType === 3 /* Assignment */) {
+                    break;
                 }
-                return true;
-            });
-            if (classVarDecl) {
-                let statement = classVarDecl.node;
-                while (statement) {
-                    if (statement.nodeType === 3 /* Assignment */) {
-                        break;
+                if (statement.nodeType === 54 /* TypeAnnotation */) {
+                    if (((_a = statement.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+                        statement = statement.parent;
                     }
-                    if (statement.nodeType === 54 /* TypeAnnotation */) {
-                        if (((_a = statement.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
-                            statement = statement.parent;
-                        }
-                        break;
-                    }
-                    statement = statement.parent;
+                    break;
                 }
-                if (!statement) {
-                    return;
+                statement = statement.parent;
+            }
+            if (!statement) {
+                return;
+            }
+            let variableNameNode;
+            let aliasName;
+            let variableTypeEvaluator;
+            let hasDefaultValue = false;
+            let isKeywordOnly = types_1.ClassType.isDataClassKeywordOnlyParams(classType) || sawKeywordOnlySeparator;
+            let defaultValueExpression;
+            let includeInInit = true;
+            let converter;
+            if (statement.nodeType === 3 /* Assignment */) {
+                if (statement.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
+                    statement.leftExpression.valueExpression.nodeType === 38 /* Name */) {
+                    variableNameNode = statement.leftExpression.valueExpression;
+                    const assignmentStatement = statement;
+                    variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.leftExpression.typeAnnotation, {
+                        isVariableAnnotation: true,
+                        allowFinal: true,
+                        allowClassVar: true,
+                    });
                 }
-                let variableNameNode;
-                let aliasName;
-                let variableTypeEvaluator;
-                let hasDefaultValue = false;
-                let isKeywordOnly = types_1.ClassType.isDataClassKeywordOnlyParams(classType) || sawKeywordOnlySeparator;
-                let defaultValueExpression;
-                let includeInInit = true;
-                let converter;
-                if (statement.nodeType === 3 /* Assignment */) {
-                    if (statement.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
-                        statement.leftExpression.valueExpression.nodeType === 38 /* Name */) {
-                        variableNameNode = statement.leftExpression.valueExpression;
-                        const assignmentStatement = statement;
-                        variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.leftExpression.typeAnnotation, {
-                            isVariableAnnotation: true,
-                            allowFinal: true,
-                            allowClassVar: true,
-                        });
-                    }
-                    hasDefaultValue = true;
-                    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 */);
-                        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;
-                                }
+                hasDefaultValue = true;
+                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 */);
+                    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;
                             }
-                            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 initCall = evaluator.getBoundMethod(callType, '__init__');
-                                    if (initCall) {
-                                        if ((0, types_1.isFunction)(initCall)) {
-                                            callTarget = initCall;
-                                        }
-                                        else if ((0, types_1.isOverloadedFunction)(initCall)) {
-                                            callTarget = evaluator.getBestOverloadForArguments(statement.rightExpression, { type: initCall }, statement.rightExpression.arguments);
-                                        }
+                        }
+                        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 initCall = evaluator.getBoundMethod(callType, '__init__');
+                                if (initCall) {
+                                    if ((0, types_1.isFunction)(initCall)) {
+                                        callTarget = initCall;
                                     }
-                                }
-                                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;
-                                            }
-                                        }
+                                    else if ((0, types_1.isOverloadedFunction)(initCall)) {
+                                        callTarget = evaluator.getBestOverloadForArguments(statement.rightExpression, { type: initCall }, statement.rightExpression.arguments);
                                     }
                                 }
                             }
-                            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;
+                            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;
+                                        }
+                                    }
                                 }
                             }
-                            const defaultArg = statement.rightExpression.arguments.find((arg) => {
-                                var _a, _b, _c;
-                                return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'default' ||
-                                    ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.value) === 'default_factory' ||
-                                    ((_c = arg.name) === null || _c === void 0 ? void 0 : _c.value) === 'factory';
-                            });
-                            hasDefaultValue = !!defaultArg;
-                            if (defaultArg === null || defaultArg === void 0 ? void 0 : defaultArg.valueExpression) {
-                                defaultValueExpression = defaultArg.valueExpression;
-                            }
-                            const aliasArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'alias'; });
-                            if (aliasArg) {
-                                const valueType = evaluator.getTypeOfExpression(aliasArg.valueExpression).type;
-                                if ((0, types_1.isClassInstance)(valueType) &&
-                                    types_1.ClassType.isBuiltIn(valueType, 'str') &&
-                                    (0, typeUtils_1.isLiteralType)(valueType)) {
-                                    aliasName = valueType.literalValue;
-                                }
+                        }
+                        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;
                             }
-                            const converterArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'converter'; });
-                            if (converterArg && converterArg.valueExpression) {
-                                converter = converterArg;
+                            else if (value === true) {
+                                isKeywordOnly = true;
                             }
                         }
-                    }
-                }
-                else if (statement.nodeType === 54 /* TypeAnnotation */) {
-                    if (statement.valueExpression.nodeType === 38 /* Name */) {
-                        variableNameNode = statement.valueExpression;
-                        const annotationStatement = statement;
-                        variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.typeAnnotation, {
-                            isVariableAnnotation: true,
-                            allowFinal: true,
-                            allowClassVar: true,
+                        const defaultArg = statement.rightExpression.arguments.find((arg) => {
+                            var _a, _b, _c;
+                            return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'default' ||
+                                ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.value) === 'default_factory' ||
+                                ((_c = arg.name) === null || _c === void 0 ? void 0 : _c.value) === 'factory';
                         });
-                        // Is this a KW_ONLY separator introduced in Python 3.10?
-                        if (statement.valueExpression.value === '_') {
-                            const annotatedType = variableTypeEvaluator();
-                            if ((0, types_1.isClassInstance)(annotatedType) && types_1.ClassType.isBuiltIn(annotatedType, 'KW_ONLY')) {
-                                sawKeywordOnlySeparator = true;
-                                variableNameNode = undefined;
-                                variableTypeEvaluator = undefined;
+                        hasDefaultValue = !!defaultArg;
+                        if (defaultArg === null || defaultArg === void 0 ? void 0 : defaultArg.valueExpression) {
+                            defaultValueExpression = defaultArg.valueExpression;
+                        }
+                        const aliasArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'alias'; });
+                        if (aliasArg) {
+                            const valueType = evaluator.getTypeOfExpression(aliasArg.valueExpression).type;
+                            if ((0, types_1.isClassInstance)(valueType) &&
+                                types_1.ClassType.isBuiltIn(valueType, 'str') &&
+                                (0, typeUtils_1.isLiteralType)(valueType)) {
+                                aliasName = valueType.literalValue;
                             }
                         }
+                        const converterArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'converter'; });
+                        if (converterArg && converterArg.valueExpression) {
+                            converter = converterArg;
+                        }
                     }
                 }
-                if (variableNameNode && variableTypeEvaluator) {
-                    const variableName = variableNameNode.value;
-                    // 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);
-                    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.
-                        // We exclude final variables here because a Final type annotation is implicitly
-                        // considered a ClassVar by the binder, but dataclass rules are different.
-                        const index = fullDataClassEntries.findIndex((p) => p.name === variableName);
-                        if (index >= 0) {
-                            fullDataClassEntries.splice(index, 1);
+            }
+            else if (statement.nodeType === 54 /* TypeAnnotation */) {
+                if (statement.valueExpression.nodeType === 38 /* Name */) {
+                    variableNameNode = statement.valueExpression;
+                    const annotationStatement = statement;
+                    variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.typeAnnotation, {
+                        isVariableAnnotation: true,
+                        allowFinal: true,
+                        allowClassVar: true,
+                    });
+                    // Is this a KW_ONLY separator introduced in Python 3.10?
+                    if (statement.valueExpression.value === '_') {
+                        const annotatedType = variableTypeEvaluator();
+                        if ((0, types_1.isClassInstance)(annotatedType) && types_1.ClassType.isBuiltIn(annotatedType, 'KW_ONLY')) {
+                            sawKeywordOnlySeparator = true;
+                            variableNameNode = undefined;
+                            variableTypeEvaluator = undefined;
                         }
-                        const dataClassEntry = {
-                            name: variableName,
-                            classType,
-                            alias: aliasName,
-                            isKeywordOnly: false,
-                            hasDefault: hasDefaultValue,
-                            defaultValueExpression,
-                            includeInInit,
-                            nameNode: variableNameNode,
-                            type: types_1.UnknownType.create(),
-                            isClassVar: true,
-                            converter,
-                        };
-                        localDataClassEntries.push(dataClassEntry);
+                    }
+                }
+            }
+            if (variableNameNode && variableTypeEvaluator) {
+                const variableName = variableNameNode.value;
+                // 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);
+                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.
+                    // We exclude final variables here because a Final type annotation is implicitly
+                    // considered a ClassVar by the binder, but dataclass rules are different.
+                    const index = fullDataClassEntries.findIndex((p) => p.name === variableName);
+                    if (index >= 0) {
+                        fullDataClassEntries.splice(index, 1);
+                    }
+                    const dataClassEntry = {
+                        name: variableName,
+                        classType,
+                        alias: aliasName,
+                        isKeywordOnly: false,
+                        hasDefault: hasDefaultValue,
+                        defaultValueExpression,
+                        includeInInit,
+                        nameNode: variableNameNode,
+                        type: types_1.UnknownType.create(),
+                        isClassVar: true,
+                        converter,
+                    };
+                    localDataClassEntries.push(dataClassEntry);
+                }
+                else {
+                    // Create a new data class entry, but defer evaluation of the type until
+                    // we've compiled the full list of data class entries for this class. This
+                    // allows us to handle circular references in types.
+                    const dataClassEntry = {
+                        name: variableName,
+                        classType,
+                        alias: aliasName,
+                        isKeywordOnly,
+                        hasDefault: hasDefaultValue,
+                        defaultValueExpression,
+                        includeInInit,
+                        nameNode: variableNameNode,
+                        type: types_1.UnknownType.create(),
+                        isClassVar: false,
+                        converter,
+                    };
+                    localEntryTypeEvaluator.push({ entry: dataClassEntry, evaluator: variableTypeEvaluator });
+                    // Add the new entry to the local entry list.
+                    let insertIndex = localDataClassEntries.findIndex((e) => e.name === variableName);
+                    if (insertIndex >= 0) {
+                        localDataClassEntries[insertIndex] = dataClassEntry;
                     }
                     else {
-                        // Create a new data class entry, but defer evaluation of the type until
-                        // we've compiled the full list of data class entries for this class. This
-                        // allows us to handle circular references in types.
-                        const dataClassEntry = {
-                            name: variableName,
-                            classType,
-                            alias: aliasName,
-                            isKeywordOnly,
-                            hasDefault: hasDefaultValue,
-                            defaultValueExpression,
-                            includeInInit,
-                            nameNode: variableNameNode,
-                            type: types_1.UnknownType.create(),
-                            isClassVar: false,
-                            converter,
-                        };
-                        localEntryTypeEvaluator.push({ entry: dataClassEntry, evaluator: variableTypeEvaluator });
-                        // Add the new entry to the local entry list.
-                        let insertIndex = localDataClassEntries.findIndex((e) => e.name === variableName);
-                        if (insertIndex >= 0) {
-                            localDataClassEntries[insertIndex] = dataClassEntry;
-                        }
-                        else {
-                            localDataClassEntries.push(dataClassEntry);
-                        }
-                        // Add the new entry to the full entry list.
-                        insertIndex = fullDataClassEntries.findIndex((p) => p.name === variableName);
-                        if (insertIndex >= 0) {
-                            const oldEntry = fullDataClassEntries[insertIndex];
-                            // While this isn't documented behavior, it appears that the dataclass implementation
-                            // causes overridden variables to "inherit" default values from parent classes.
-                            if (!dataClassEntry.hasDefault && oldEntry.hasDefault && oldEntry.includeInInit) {
-                                dataClassEntry.hasDefault = true;
-                                dataClassEntry.defaultValueExpression = oldEntry.defaultValueExpression;
-                                hasDefaultValue = true;
-                            }
-                            fullDataClassEntries[insertIndex] = dataClassEntry;
-                        }
-                        else {
-                            fullDataClassEntries.push(dataClassEntry);
-                            insertIndex = fullDataClassEntries.length - 1;
+                        localDataClassEntries.push(dataClassEntry);
+                    }
+                    // Add the new entry to the full entry list.
+                    insertIndex = fullDataClassEntries.findIndex((p) => p.name === variableName);
+                    if (insertIndex >= 0) {
+                        const oldEntry = fullDataClassEntries[insertIndex];
+                        // While this isn't documented behavior, it appears that the dataclass implementation
+                        // causes overridden variables to "inherit" default values from parent classes.
+                        if (!dataClassEntry.hasDefault && oldEntry.hasDefault && oldEntry.includeInInit) {
+                            dataClassEntry.hasDefault = true;
+                            dataClassEntry.defaultValueExpression = oldEntry.defaultValueExpression;
+                            hasDefaultValue = true;
                         }
-                        // If we've already seen a entry with a default value defined,
-                        // all subsequent entries must also have default values.
-                        if (!isKeywordOnly && includeInInit && !skipSynthesizeInit && !hasDefaultValue) {
-                            const firstDefaultValueIndex = fullDataClassEntries.findIndex((p) => p.hasDefault && p.includeInInit && !p.isKeywordOnly);
-                            if (firstDefaultValueIndex >= 0 && firstDefaultValueIndex < insertIndex) {
-                                evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassFieldWithDefault(), variableNameNode);
-                            }
+                        fullDataClassEntries[insertIndex] = dataClassEntry;
+                    }
+                    else {
+                        fullDataClassEntries.push(dataClassEntry);
+                        insertIndex = fullDataClassEntries.length - 1;
+                    }
+                    // If we've already seen a entry with a default value defined,
+                    // all subsequent entries must also have default values.
+                    if (!isKeywordOnly && includeInInit && !skipSynthesizeInit && !hasDefaultValue) {
+                        const firstDefaultValueIndex = fullDataClassEntries.findIndex((p) => p.hasDefault && p.includeInInit && !p.isKeywordOnly);
+                        if (firstDefaultValueIndex >= 0 && firstDefaultValueIndex < insertIndex) {
+                            evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassFieldWithDefault(), variableNameNode);
                         }
                     }
                 }
             }
-            else {
-                // The symbol had no declared type, so it is (mostly) ignored by dataclasses.
-                // However, if it is assigned a field descriptor, it will result in a
-                // runtime exception.
-                const declarations = symbol.getDeclarations();
-                if (declarations.length === 0) {
-                    return;
-                }
-                const lastDecl = declarations[declarations.length - 1];
-                if (lastDecl.type !== 1 /* Variable */) {
-                    return;
-                }
-                const statement = lastDecl.node.parent;
-                if (!statement || statement.nodeType !== 3 /* 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) || [])) {
-                        evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassFieldWithoutAnnotation(), statement.rightExpression);
-                    }
+        }
+        else {
+            // The symbol had no declared type, so it is (mostly) ignored by dataclasses.
+            // However, if it is assigned a field descriptor, it will result in a
+            // runtime exception.
+            const declarations = symbol.getDeclarations();
+            if (declarations.length === 0) {
+                return;
+            }
+            const lastDecl = declarations[declarations.length - 1];
+            if (lastDecl.type !== 1 /* Variable */) {
+                return;
+            }
+            const statement = lastDecl.node.parent;
+            if (!statement || statement.nodeType !== 3 /* 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) || [])) {
+                    evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassFieldWithoutAnnotation(), statement.rightExpression);
                 }
             }
         }