@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

package/dist/analyzer/typeGuards.js

@@ -59,27 +59,27 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
         return getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount);
     }
     if (testExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
-        const isOrIsNotOperator = testExpression.operator === 39 /* OperatorType.Is */ || testExpression.operator === 40 /* OperatorType.IsNot */;
-        const equalsOrNotEqualsOperator = testExpression.operator === 12 /* OperatorType.Equals */ || testExpression.operator === 28 /* OperatorType.NotEquals */;
+        const isOrIsNotOperator = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 40 /* OperatorType.IsNot */;
+        const equalsOrNotEqualsOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
         const comparisonOperator = equalsOrNotEqualsOperator ||
-            testExpression.operator === 20 /* OperatorType.LessThan */ ||
-            testExpression.operator === 21 /* OperatorType.LessThanOrEqual */ ||
-            testExpression.operator === 15 /* OperatorType.GreaterThan */ ||
-            testExpression.operator === 16 /* OperatorType.GreaterThanOrEqual */;
+            testExpression.d.operator === 20 /* OperatorType.LessThan */ ||
+            testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
+            testExpression.d.operator === 15 /* OperatorType.GreaterThan */ ||
+            testExpression.d.operator === 16 /* OperatorType.GreaterThanOrEqual */;
         if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
             // Invert the "isPositiveTest" value if this is an "is not" operation.
-            const adjIsPositiveTest = testExpression.operator === 39 /* OperatorType.Is */ || testExpression.operator === 12 /* OperatorType.Equals */
+            const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 12 /* OperatorType.Equals */
                 ? isPositiveTest
                 : !isPositiveTest;
             // Look for "X is None", "X is not None", "X == None", and "X != None".
             // These are commonly-used patterns used in control flow.
-            if (testExpression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
-                testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
+            if (testExpression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
+                testExpression.d.rightExpr.d.constType === 26 /* KeywordType.None */) {
                 // Allow the LHS to be either a simple expression or an assignment
                 // expression that assigns to a simple name.
-                let leftExpression = testExpression.leftExpression;
+                let leftExpression = testExpression.d.leftExpr;
                 if (leftExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
-                    leftExpression = leftExpression.name;
+                    leftExpression = leftExpression.d.name;
                 }
                 if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
                     return (type) => {
@@ -87,15 +87,15 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     };
                 }
                 if (leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
-                    ParseTreeUtils.isMatchingExpression(reference, leftExpression.baseExpression) &&
-                    leftExpression.items.length === 1 &&
-                    !leftExpression.trailingComma &&
-                    leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                    !leftExpression.items[0].name &&
-                    leftExpression.items[0].valueExpression.nodeType === 40 /* ParseNodeType.Number */ &&
-                    leftExpression.items[0].valueExpression.isInteger &&
-                    !leftExpression.items[0].valueExpression.isImaginary) {
-                    const indexValue = leftExpression.items[0].valueExpression.value;
+                    ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr) &&
+                    leftExpression.d.items.length === 1 &&
+                    !leftExpression.d.trailingComma &&
+                    leftExpression.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    !leftExpression.d.items[0].d.name &&
+                    leftExpression.d.items[0].d.valueExpr.nodeType === 40 /* ParseNodeType.Number */ &&
+                    leftExpression.d.items[0].d.valueExpr.d.isInteger &&
+                    !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
+                    const indexValue = leftExpression.d.items[0].d.valueExpr.d.value;
                     if (typeof indexValue === 'number') {
                         return (type) => {
                             return {
@@ -107,12 +107,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
             // Look for "X is ...", "X is not ...", "X == ...", and "X != ...".
-            if (testExpression.rightExpression.nodeType === 21 /* ParseNodeType.Ellipsis */) {
+            if (testExpression.d.rightExpr.nodeType === 21 /* ParseNodeType.Ellipsis */) {
                 // Allow the LHS to be either a simple expression or an assignment
                 // expression that assigns to a simple name.
-                let leftExpression = testExpression.leftExpression;
+                let leftExpression = testExpression.d.leftExpr;
                 if (leftExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
-                    leftExpression = leftExpression.name;
+                    leftExpression = leftExpression.d.name;
                 }
                 if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
                     return (type) => {
@@ -124,14 +124,14 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
             // Look for "type(X) is Y", "type(X) is not Y", "type(X) == Y" or "type(X) != Y".
-            if (testExpression.leftExpression.nodeType === 9 /* ParseNodeType.Call */) {
-                if (testExpression.leftExpression.arguments.length === 1 &&
-                    testExpression.leftExpression.arguments[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
-                    const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
+            if (testExpression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */) {
+                if (testExpression.d.leftExpr.d.args.length === 1 &&
+                    testExpression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgumentCategory.Simple */) {
+                    const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
                     if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                        const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
+                        const callType = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type;
                         if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
-                            const classTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                            const classTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                             const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
                             if ((0, types_1.isInstantiableClass)(classType)) {
                                 return (type) => {
@@ -146,13 +146,13 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
             if (isOrIsNotOperator) {
-                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
-                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                     const rightType = rightTypeResult.type;
                     // Look for "X is Y" or "X is not Y" where Y is a an enum or bool literal.
                     if ((0, types_1.isClassInstance)(rightType) &&
                         (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
-                        rightType.literalValue !== undefined) {
+                        rightType.priv.literalValue !== undefined) {
                         return (type) => {
                             return {
                                 type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
@@ -172,17 +172,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     }
                 }
                 // Look for X[<literal>] is <literal> or X[<literal>] is not <literal>.
-                if (testExpression.leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
-                    testExpression.leftExpression.items.length === 1 &&
-                    !testExpression.leftExpression.trailingComma &&
-                    testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                    ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
-                    const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
+                if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
+                    testExpression.d.leftExpr.d.items.length === 1 &&
+                    !testExpression.d.leftExpr.d.trailingComma &&
+                    testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+                    const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
                     const indexType = indexTypeResult.type;
                     if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
                         if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
-                            const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
-                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            const rightType = evaluator.getTypeOfExpression(testExpression.d.rightExpr).type;
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
@@ -192,15 +192,15 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                             }
                         }
                         else if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
-                            const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                            const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                             const rightType = rightTypeResult.type;
-                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
                                 let canNarrow = false;
                                 // Narrowing can be applied only for bool or enum literals.
                                 if (types_1.ClassType.isBuiltIn(rightType, 'bool')) {
                                     canNarrow = true;
                                 }
-                                else if (rightType.literalValue instanceof types_1.EnumLiteral) {
+                                else if (rightType.priv.literalValue instanceof types_1.EnumLiteral) {
                                     canNarrow = true;
                                 }
                                 if (canNarrow) {
@@ -218,16 +218,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             if (equalsOrNotEqualsOperator) {
                 // Look for X == <literal> or X != <literal>
-                const adjIsPositiveTest = testExpression.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
-                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
+                const adjIsPositiveTest = testExpression.d.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
+                if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
                     // Use speculative mode here to avoid polluting the type cache. This is
                     // important in cases where evaluation of the right expression creates
                     // a false dependency on another variable.
-                    const rightTypeResult = evaluator.useSpeculativeMode(testExpression.rightExpression, () => {
-                        return evaluator.getTypeOfExpression(testExpression.rightExpression);
+                    const rightTypeResult = evaluator.useSpeculativeMode(testExpression.d.rightExpr, () => {
+                        return evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                     });
                     const rightType = rightTypeResult.type;
-                    if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                    if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
                         return (type) => {
                             return {
                                 type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
@@ -238,16 +238,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     }
                 }
                 // Look for X[<literal>] == <literal> or X[<literal>] != <literal>
-                if (testExpression.leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
-                    testExpression.leftExpression.items.length === 1 &&
-                    !testExpression.leftExpression.trailingComma &&
-                    testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                    ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
-                    const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
+                if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
+                    testExpression.d.leftExpr.d.items.length === 1 &&
+                    !testExpression.d.leftExpr.d.trailingComma &&
+                    testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+                    const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
                     const indexType = indexTypeResult.type;
                     if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
                         if (types_1.ClassType.isBuiltIn(indexType, ['str', 'int'])) {
-                            const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                            const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                             const rightType = rightTypeResult.type;
                             if ((0, typeUtils_1.isLiteralTypeOrUnion)(rightType)) {
                                 return (type) => {
@@ -270,16 +270,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for X.Y == <literal> or X.Y != <literal>
             if (equalsOrNotEqualsOperator &&
-                testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
-                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                testExpression.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                 const rightType = rightTypeResult.type;
-                const memberName = testExpression.leftExpression.memberName;
+                const memberName = testExpression.d.leftExpr.d.member;
                 if ((0, types_1.isClassInstance)(rightType)) {
-                    if (rightType.literalValue !== undefined || (0, typeUtils_1.isNoneInstance)(rightType)) {
+                    if (rightType.priv.literalValue !== undefined || (0, typeUtils_1.isNoneInstance)(rightType)) {
                         return (type) => {
                             return {
-                                type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
+                                type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.d.value, rightType, adjIsPositiveTest),
                                 isIncomplete: !!rightTypeResult.isIncomplete,
                             };
                         };
@@ -288,17 +288,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for X.Y is <literal> or X.Y is not <literal> where <literal> is
             // an enum or bool literal
-            if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
-                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+            if (testExpression.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                 const rightType = rightTypeResult.type;
-                const memberName = testExpression.leftExpression.memberName;
+                const memberName = testExpression.d.leftExpr.d.member;
                 if ((0, types_1.isClassInstance)(rightType) &&
                     (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
-                    rightType.literalValue !== undefined) {
+                    rightType.priv.literalValue !== undefined) {
                     return (type) => {
                         return {
-                            type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
+                            type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.d.value, rightType, adjIsPositiveTest),
                             isIncomplete: !!rightTypeResult.isIncomplete,
                         };
                     };
@@ -306,14 +306,14 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
             // Look for X.Y is None or X.Y is not None
             // These are commonly-used patterns used in control flow.
-            if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression) &&
-                testExpression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
-                testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
-                const memberName = testExpression.leftExpression.memberName;
+            if (testExpression.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr) &&
+                testExpression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
+                testExpression.d.rightExpr.d.constType === 26 /* KeywordType.None */) {
+                const memberName = testExpression.d.leftExpr.d.member;
                 return (type) => {
                     return {
-                        type: narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.value, adjIsPositiveTest),
+                        type: narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.d.value, adjIsPositiveTest),
                         isIncomplete: false,
                     };
                 };
@@ -321,32 +321,32 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
         }
         // Look for len(x) == <literal>, len(x) != <literal>, len(x) < <literal>, etc.
         if (comparisonOperator &&
-            testExpression.leftExpression.nodeType === 9 /* ParseNodeType.Call */ &&
-            testExpression.leftExpression.arguments.length === 1) {
-            const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
+            testExpression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */ &&
+            testExpression.d.leftExpr.d.args.length === 1) {
+            const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
-                if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
-                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                if ((0, types_1.isFunction)(callType) && callType.shared.fullName === 'builtins.len') {
+                    const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                     const rightType = rightTypeResult.type;
                     if ((0, types_1.isClassInstance)(rightType) &&
-                        typeof rightType.literalValue === 'number' &&
-                        rightType.literalValue >= 0) {
-                        let tupleLength = rightType.literalValue;
+                        typeof rightType.priv.literalValue === 'number' &&
+                        rightType.priv.literalValue >= 0) {
+                        let tupleLength = rightType.priv.literalValue;
                         // We'll treat <, <= and == as positive tests with >=, > and != as
                         // their negative counterparts.
-                        const isLessOrEqual = testExpression.operator === 12 /* OperatorType.Equals */ ||
-                            testExpression.operator === 20 /* OperatorType.LessThan */ ||
-                            testExpression.operator === 21 /* OperatorType.LessThanOrEqual */;
+                        const isLessOrEqual = testExpression.d.operator === 12 /* OperatorType.Equals */ ||
+                            testExpression.d.operator === 20 /* OperatorType.LessThan */ ||
+                            testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */;
                         const adjIsPositiveTest = isLessOrEqual ? isPositiveTest : !isPositiveTest;
                         // For <= (or its negative counterpart >), adjust the tuple length by 1.
-                        if (testExpression.operator === 21 /* OperatorType.LessThanOrEqual */ ||
-                            testExpression.operator === 15 /* OperatorType.GreaterThan */) {
+                        if (testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
+                            testExpression.d.operator === 15 /* OperatorType.GreaterThan */) {
                             tupleLength++;
                         }
-                        const isEqualityCheck = testExpression.operator === 12 /* OperatorType.Equals */ ||
-                            testExpression.operator === 28 /* OperatorType.NotEquals */;
+                        const isEqualityCheck = testExpression.d.operator === 12 /* OperatorType.Equals */ ||
+                            testExpression.d.operator === 28 /* OperatorType.NotEquals */;
                         return (type) => {
                             return {
                                 type: narrowTypeForTupleLength(evaluator, type, tupleLength, adjIsPositiveTest, !isEqualityCheck),
@@ -357,12 +357,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
         }
-        if (testExpression.operator === 41 /* OperatorType.In */ || testExpression.operator === 42 /* OperatorType.NotIn */) {
+        if (testExpression.d.operator === 41 /* OperatorType.In */ || testExpression.d.operator === 42 /* OperatorType.NotIn */) {
             // Look for "x in y" or "x not in y" where y is one of several built-in types.
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
-                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+                const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
                 const rightType = rightTypeResult.type;
-                const adjIsPositiveTest = testExpression.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
+                const adjIsPositiveTest = testExpression.d.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
                 return (type) => {
                     return {
                         type: narrowTypeForContainerType(evaluator, type, rightType, adjIsPositiveTest),
@@ -370,13 +370,13 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     };
                 };
             }
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.rightExpression)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.rightExpr)) {
                 // Look for <string literal> in y where y is a union that contains
                 // one or more TypedDicts.
-                const leftTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression);
+                const leftTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr);
                 const leftType = leftTypeResult.type;
                 if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
-                    const adjIsPositiveTest = testExpression.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
+                    const adjIsPositiveTest = testExpression.d.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
                     return (type) => {
                         return {
                             type: narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
@@ -389,26 +389,20 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     }
     if (testExpression.nodeType === 9 /* ParseNodeType.Call */) {
         // Look for "isinstance(X, Y)" or "issubclass(X, Y)".
-        if (testExpression.arguments.length === 2) {
+        if (testExpression.d.args.length === 2) {
             // Make sure the first parameter is a supported expression type
             // and the second parameter is a valid class type or a tuple
             // of valid class types.
-            const arg0Expr = testExpression.arguments[0].valueExpression;
-            const arg1Expr = testExpression.arguments[1].valueExpression;
+            const arg0Expr = testExpression.d.args[0].d.valueExpr;
+            const arg1Expr = testExpression.d.args[1].d.valueExpr;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
-                if ((0, types_1.isFunction)(callType) &&
-                    (callType.details.builtInName === 'isinstance' || callType.details.builtInName === 'issubclass')) {
-                    const isInstanceCheck = callType.details.builtInName === 'isinstance';
-                    const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
-                        8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                        32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16 /* EvaluatorFlags.DisallowFinal */ |
-                        2 /* EvaluatorFlags.DoNotSpecialize */);
+                if ((0, types_1.isFunction)(callType) && types_1.FunctionType.isBuiltIn(callType, ['isinstance', 'issubclass'])) {
+                    const isInstanceCheck = types_1.FunctionType.isBuiltIn(callType, 'isinstance');
+                    const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 536871546 /* EvalFlags.IsInstanceArgDefaults */);
                     const arg1Type = arg1TypeResult.type;
-                    const classTypeList = getIsInstanceClassTypes(arg1Type);
+                    const classTypeList = getIsInstanceClassTypes(evaluator, arg1Type);
                     const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
                     if (classTypeList) {
                         return (type) => {
@@ -433,12 +427,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
         }
         // Look for "callable(X)"
-        if (testExpression.arguments.length === 1) {
-            const arg0Expr = testExpression.arguments[0].valueExpression;
+        if (testExpression.d.args.length === 1) {
+            const arg0Expr = testExpression.d.args[0].d.valueExpr;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
-                if ((0, types_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
+                if ((0, types_1.isFunction)(callType) && types_1.FunctionType.isBuiltIn(callType, 'callable')) {
                     return (type) => {
                         let narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
                         /* allowIntersections */ false);
@@ -453,9 +447,9 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
         }
         // Look for "bool(X)"
-        if (testExpression.arguments.length === 1 && !testExpression.arguments[0].name) {
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.arguments[0].valueExpression)) {
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+        if (testExpression.d.args.length === 1 && !testExpression.d.args[0].d.name) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr)) {
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
                     return (type) => {
@@ -468,17 +462,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             }
         }
         // Look for a TypeGuard function.
-        if (testExpression.arguments.length >= 1) {
-            const arg0Expr = testExpression.arguments[0].valueExpression;
+        if (testExpression.d.args.length >= 1) {
+            const arg0Expr = testExpression.d.args[0].d.valueExpr;
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                 // Does this look like it's a custom type guard function?
                 let isPossiblyTypeGuard = false;
                 const isFunctionReturnTypeGuard = (type) => {
-                    return (type.details.declaredReturnType &&
-                        (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
-                        types_1.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'TypeIs']));
+                    return (type.shared.declaredReturnType &&
+                        (0, types_1.isClassInstance)(type.shared.declaredReturnType) &&
+                        types_1.ClassType.isBuiltIn(type.shared.declaredReturnType, ['TypeGuard', 'TypeIs']));
                 };
-                const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
                 if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
@@ -496,9 +490,9 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     const functionReturnType = functionReturnTypeResult.type;
                     if ((0, types_1.isClassInstance)(functionReturnType) &&
                         types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
-                        functionReturnType.typeGuardType) {
-                        const isStrictTypeGuard = !!functionReturnType.isStrictTypeGuard;
-                        const typeGuardType = functionReturnType.typeGuardType;
+                        functionReturnType.priv.typeGuardType) {
+                        const isStrictTypeGuard = !!functionReturnType.priv.isStrictTypeGuard;
+                        const typeGuardType = functionReturnType.priv.typeGuardType;
                         const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
                         return (type) => {
                             return {
@@ -529,8 +523,9 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     // by the binder when it creates condition flow nodes, but we can find this
     // in the case of local variables type narrowing.
     if (reference.nodeType === 38 /* ParseNodeType.Name */) {
-        if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ && testExpression.operator === 38 /* OperatorType.Not */) {
-            return getTypeNarrowingCallback(evaluator, reference, testExpression.expression, !isPositiveTest, recursionCount);
+        if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
+            testExpression.d.operator === 38 /* OperatorType.Not */) {
+            return getTypeNarrowingCallback(evaluator, reference, testExpression.d.expr, !isPositiveTest, recursionCount);
         }
     }
     return undefined;
@@ -592,7 +587,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
     if ((scope === null || scope === void 0 ? void 0 : scope.type) !== 2 /* ScopeType.Function */ && (scope === null || scope === void 0 ? void 0 : scope.type) !== 4 /* ScopeType.Module */) {
         return undefined;
     }
-    const symbol = scope.lookUpSymbol(name.value);
+    const symbol = scope.lookUpSymbol(name.d.value);
     if (!symbol) {
         return undefined;
     }
@@ -608,7 +603,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
     // "nonlocal" reference), don't consider it a local variable.
     let prevDeclScope;
     if (decls.some((decl) => {
-        const nodeToConsider = decl.type === 2 /* DeclarationType.Parameter */ ? decl.node.name : decl.node;
+        const nodeToConsider = decl.type === 2 /* DeclarationType.Parameter */ ? decl.node.d.name : decl.node;
         const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider);
         if (prevDeclScope && declScopeNode !== prevDeclScope) {
             return true;
@@ -623,7 +618,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
 }
 function getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
     var _a;
-    return ((_a = getTypeNarrowingCallback(evaluator, reference, testExpression.rightExpression, isPositiveTest, recursionCount)) !== null && _a !== void 0 ? _a : getTypeNarrowingCallback(evaluator, reference, testExpression.name, isPositiveTest, recursionCount));
+    return ((_a = getTypeNarrowingCallback(evaluator, reference, testExpression.d.rightExpr, isPositiveTest, recursionCount)) !== null && _a !== void 0 ? _a : getTypeNarrowingCallback(evaluator, reference, testExpression.d.name, isPositiveTest, recursionCount));
 }
 function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, errorNode) {
     // For non-strict type guards, always narrow to the typeGuardType
@@ -660,14 +655,14 @@ function narrowTypeForTruthiness(evaluator, type, isPositiveTest) {
 function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
     return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
         const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-        if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.tupleTypeArguments) {
+        if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.priv.tupleTypeArguments) {
             return subtype;
         }
-        const tupleLength = tupleType.tupleTypeArguments.length;
+        const tupleLength = tupleType.priv.tupleTypeArguments.length;
         if (indexValue < 0 || indexValue >= tupleLength) {
             return subtype;
         }
-        const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
+        const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.priv.tupleTypeArguments[indexValue].type);
         if (isPositiveTest) {
             if (!evaluator.assignType(typeOfEntry, evaluator.getNoneType())) {
                 return undefined;
@@ -689,6 +684,7 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
     let resultIncludesNoneSubtype = false;
     const result = evaluator.mapSubtypesExpandTypeVars(expandedType, 
     /* options */ undefined, (subtype, unexpandedSubtype) => {
+        var _a;
         if ((0, types_1.isAnyOrUnknown)(subtype)) {
             // We need to assume that "Any" is always both None and not None,
             // so it matches regardless of whether the test is positive or negative.
@@ -697,20 +693,20 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
         // If this is a TypeVar that isn't constrained, use the unexpanded
         // TypeVar. For all other cases (including constrained TypeVars),
         // use the expanded subtype.
-        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
             resultIncludesNoneSubtype = true;
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition)
                 : adjustedSubtype;
         }
         // See if it's a match for None.
         if ((0, typeUtils_1.isNoneInstance)(subtype) === isPositiveTest) {
             resultIncludesNoneSubtype = true;
-            if ((0, types_1.isTypeVar)(adjustedSubtype) && adjustedSubtype.details.isSynthesizedSelf) {
+            if ((0, types_1.isTypeVar)(adjustedSubtype) && adjustedSubtype.shared.isSynthesizedSelf) {
                 return adjustedSubtype;
             }
             return subtype;
@@ -733,6 +729,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
         return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
     });
     return evaluator.mapSubtypesExpandTypeVars(expandedType, /* options */ undefined, (subtype, unexpandedSubtype) => {
+        var _a;
         if ((0, types_1.isAnyOrUnknown)(subtype)) {
             // We need to assume that "Any" is always both None and not None,
             // so it matches regardless of whether the test is positive or negative.
@@ -741,12 +738,14 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
         // If this is a TypeVar that isn't constrained, use the unexpanded
         // TypeVar. For all other cases (including constrained TypeVars),
         // use the expanded subtype.
-        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
-            return isPositiveTest ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.condition) : adjustedSubtype;
+            return isPositiveTest
+                ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition)
+                : adjustedSubtype;
         }
         const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['EllipsisType', 'ellipsis']);
         // See if it's a match for "...".
@@ -760,7 +759,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
 // that accepts a single class, and a more complex form that accepts a tuple
 // of classes (including arbitrarily-nested tuples). This method determines
 // which form and returns a list of classes or undefined.
-function getIsInstanceClassTypes(argType) {
+function getIsInstanceClassTypes(evaluator, argType) {
     let foundNonClassType = false;
     const classTypeList = [];
     // Create a helper function that returns a list of class types or
@@ -768,7 +767,7 @@ function getIsInstanceClassTypes(argType) {
     const addClassTypesToList = (types) => {
         types.forEach((subtype) => {
             if ((0, types_1.isClass)(subtype)) {
-                subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype);
+                subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype, evaluator.getTupleClassType());
                 if ((0, types_1.isInstantiableClass)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Callable')) {
                     subtype = (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.getUnknownTypeForCallable)());
                 }
@@ -781,9 +780,9 @@ function getIsInstanceClassTypes(argType) {
                 classTypeList.push(subtype);
             }
             else if ((0, types_1.isFunction)(subtype) &&
-                subtype.details.parameters.length === 2 &&
-                subtype.details.parameters[0].category === 1 /* ParameterCategory.ArgsList */ &&
-                subtype.details.parameters[1].category === 2 /* ParameterCategory.KwargsDict */) {
+                subtype.shared.parameters.length === 2 &&
+                subtype.shared.parameters[0].category === 1 /* ParameterCategory.ArgsList */ &&
+                subtype.shared.parameters[1].category === 2 /* ParameterCategory.KwargsDict */) {
                 classTypeList.push(subtype);
             }
             else {
@@ -796,8 +795,8 @@ function getIsInstanceClassTypes(argType) {
             return;
         }
         if ((0, types_1.isClass)(type) && types_1.TypeBase.isInstance(type) && (0, typeUtils_1.isTupleClass)(type)) {
-            if (type.tupleTypeArguments) {
-                type.tupleTypeArguments.forEach((tupleEntry) => {
+            if (type.priv.tupleTypeArguments) {
+                type.priv.tupleTypeArguments.forEach((tupleEntry) => {
                     addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
                 });
             }
@@ -814,13 +813,13 @@ function getIsInstanceClassTypes(argType) {
     return foundNonClassType ? undefined : classTypeList;
 }
 function isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck) {
-    if ((0, types_1.isTypeVar)(filterType) || concreteFilterType.literalValue !== undefined) {
+    if ((0, types_1.isTypeVar)(filterType) || concreteFilterType.priv.literalValue !== undefined) {
         return (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), varType);
     }
     // If the filter type represents all possible subclasses
     // of a type, we can't make any statements about its superclass
     // relationship with concreteVarType.
-    if (concreteFilterType.includeSubclasses) {
+    if (concreteFilterType.priv.includeSubclasses) {
         return false;
     }
     if (types_1.ClassType.isDerivedFrom(concreteVarType, concreteFilterType)) {
@@ -878,6 +877,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
     // and returns the list of types the varType could be after
     // applying the filter.
     const filterClassType = (varType, concreteVarType, conditions, negativeFallbackType) => {
+        var _a, _b, _c;
         const filteredTypes = [];
         let foundSuperclass = false;
         let isClassRelationshipIndeterminate = false;
@@ -894,10 +894,10 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                     // If the class was implicitly specialized (e.g. because its type
                     // parameters have default values), replace the default type arguments
                     // with Unknown.
-                    if (concreteFilterType.typeArguments && !concreteFilterType.isTypeArgumentExplicit) {
+                    if (concreteFilterType.priv.typeArguments && !concreteFilterType.priv.isTypeArgumentExplicit) {
                         concreteFilterType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(types_1.ClassType.cloneForSpecialization(concreteFilterType, 
                         /* typeArguments */ undefined, 
-                        /* isTypeArgumentExplicit */ false));
+                        /* isTypeArgumentExplicit */ false), evaluator.getTupleClassType());
                     }
                     filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck);
                     filterIsSubclass = isIsinstanceFilterSubclass(evaluator, concreteVarType, concreteFilterType, isInstanceCheck);
@@ -925,7 +925,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         // If the variable type is a subclass of the isinstance filter,
                         // we haven't learned anything new about the variable type.
                         // If the varType is a Self or type[Self], retain the unnarrowedType.
-                        if ((0, types_1.isTypeVar)(varType) && varType.details.isSynthesizedSelf) {
+                        if ((0, types_1.isTypeVar)(varType) && varType.shared.isSynthesizedSelf) {
                             filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, conditions));
                         }
                         else {
@@ -947,17 +947,21 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                             // be passed to isinstance or issubclass.
                             if ((0, types_1.isClass)(filterType)) {
                                 if (types_1.ClassType.isSpecialBuiltIn(filterType) ||
-                                    filterType.details.typeParameters.length > 0) {
-                                    if (!filterType.typeArguments ||
-                                        !filterType.isTypeArgumentExplicit ||
+                                    filterType.shared.typeParameters.length > 0) {
+                                    if (!filterType.priv.typeArguments ||
+                                        !filterType.priv.isTypeArgumentExplicit ||
                                         !types_1.ClassType.isSameGenericClass(concreteVarType, filterType)) {
                                         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
                                         const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
                                         /* typeArguments */ undefined, 
                                         /* isTypeArgumentExplicit */ false);
-                                        if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext, 
+                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext, 
                                         /* liveTypeVarScopes */ undefined, errorNode.start)) {
-                                            specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true, useUnknownOverDefault: true });
+                                            specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, {
+                                                unknownIfNotFound: true,
+                                                useUnknownOverDefault: true,
+                                                tupleClassType: evaluator.getTupleClassType(),
+                                            });
                                         }
                                     }
                                 }
@@ -973,34 +977,34 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         // be a mix-in class used with the other. In this case, we'll
                         // synthesize a new class type that represents an intersection of
                         // the two types.
-                        const className = `<subclass of ${concreteVarType.details.name} and ${concreteFilterType.details.name}>`;
+                        const className = `<subclass of ${concreteVarType.shared.name} and ${concreteFilterType.shared.name}>`;
                         const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
                         // The effective metaclass of the intersection is the narrower of the two metaclasses.
-                        let effectiveMetaclass = concreteVarType.details.effectiveMetaclass;
-                        if (concreteFilterType.details.effectiveMetaclass) {
+                        let effectiveMetaclass = concreteVarType.shared.effectiveMetaclass;
+                        if (concreteFilterType.shared.effectiveMetaclass) {
                             if (!effectiveMetaclass ||
-                                evaluator.assignType(effectiveMetaclass, concreteFilterType.details.effectiveMetaclass)) {
-                                effectiveMetaclass = concreteFilterType.details.effectiveMetaclass;
+                                evaluator.assignType(effectiveMetaclass, concreteFilterType.shared.effectiveMetaclass)) {
+                                effectiveMetaclass = concreteFilterType.shared.effectiveMetaclass;
                             }
                         }
                         let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
-                        /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.details.docString);
-                        newClassType.details.baseClasses = [
+                        /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.shared.docString);
+                        newClassType.shared.baseClasses = [
                             types_1.ClassType.cloneAsInstantiable(concreteVarType),
                             concreteFilterType,
                         ];
                         (0, typeUtils_1.computeMroLinearization)(newClassType);
-                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, concreteFilterType.condition);
+                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = concreteFilterType.props) === null || _a === void 0 ? void 0 : _a.condition);
                         if ((0, types_1.isTypeVar)(varType) &&
-                            !varType.details.isParamSpec &&
-                            varType.details.constraints.length === 0) {
+                            !varType.shared.isParamSpec &&
+                            varType.shared.constraints.length === 0) {
                             newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
                                 { typeVar: varType, constraintIndex: 0 },
                             ]);
                         }
                         let newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
-                        if (concreteVarType.condition) {
-                            newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, concreteVarType.condition);
+                        if ((_b = concreteVarType.props) === null || _b === void 0 ? void 0 : _b.condition) {
+                            newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, (_c = concreteVarType.props) === null || _c === void 0 ? void 0 : _c.condition);
                         }
                         // If this is a issubclass check, we do a double conversion from instantiable
                         // to instance back to instantiable to make sure that the includeSubclasses flag
@@ -1111,14 +1115,14 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
         for (const filterType of filterTypes) {
             const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
             if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
-                const filterMetaclass = concreteFilterType.details.effectiveMetaclass;
+                const filterMetaclass = concreteFilterType.shared.effectiveMetaclass;
                 if (filterMetaclass && (0, types_1.isInstantiableClass)(filterMetaclass)) {
                     let isMetaclassOverlap = evaluator.assignType(metaclassType, types_1.ClassType.cloneAsInstance(filterMetaclass));
                     // Handle the special case where the metaclass for the filter is type.
                     // This will normally be treated as type[Any], which is compatible with
                     // any metaclass, but we specifically want to treat type as the class
                     // type[object] in this case.
-                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.isTypeArgumentExplicit) {
+                    if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgumentExplicit) {
                         if (!types_1.ClassType.isBuiltIn(metaclassType, 'type')) {
                             isMetaclassOverlap = false;
                         }
@@ -1128,7 +1132,8 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                             filteredTypes.push(filterType);
                             foundPositiveMatch = true;
                         }
-                        else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) || filterMetaclass.includeSubclasses) {
+                        else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) ||
+                            filterMetaclass.priv.includeSubclasses) {
                             filteredTypes.push(metaclassType);
                             isMatchIndeterminate = true;
                         }
@@ -1302,23 +1307,23 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
         // If it's not a tuple, we can't narrow it.
         if (!(0, types_1.isClassInstance)(concreteSubtype) ||
             !(0, typeUtils_1.isTupleClass)(concreteSubtype) ||
-            !concreteSubtype.tupleTypeArguments) {
+            !concreteSubtype.priv.tupleTypeArguments) {
             return subtype;
         }
         // If the tuple contains a variadic TypeVar, we can't narrow it.
-        if (concreteSubtype.tupleTypeArguments.some((typeArg) => (0, types_1.isUnpackedVariadicTypeVar)(typeArg.type))) {
+        if (concreteSubtype.priv.tupleTypeArguments.some((typeArg) => (0, types_1.isUnpackedVariadicTypeVar)(typeArg.type))) {
             return subtype;
         }
         // If the tuple contains no unbounded elements, then we know its length exactly.
-        if (!concreteSubtype.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
+        if (!concreteSubtype.priv.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
             const tupleLengthMatches = isLessThanCheck
-                ? concreteSubtype.tupleTypeArguments.length < lengthValue
-                : concreteSubtype.tupleTypeArguments.length === lengthValue;
+                ? concreteSubtype.priv.tupleTypeArguments.length < lengthValue
+                : concreteSubtype.priv.tupleTypeArguments.length === lengthValue;
             return tupleLengthMatches === isPositiveTest ? subtype : undefined;
         }
         // The tuple contains a "...". We'll expand this into as many elements as
         // necessary to match the lengthValue.
-        const elementsToAdd = lengthValue - concreteSubtype.tupleTypeArguments.length + 1;
+        const elementsToAdd = lengthValue - concreteSubtype.priv.tupleTypeArguments.length + 1;
         if (!isLessThanCheck) {
             // If the specified length is smaller than the minimum length of this tuple,
             // we can rule it out for a positive test and rule it in for a negative test.
@@ -1331,7 +1336,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
             return expandUnboundedTupleElement(concreteSubtype, elementsToAdd, /* keepUnbounded */ false);
         }
         // If this is a tuple related to an "*args: P.args" parameter, don't expand it.
-        if ((0, types_1.isParamSpec)(subtype) && subtype.paramSpecAccess) {
+        if ((0, types_1.isParamSpec)(subtype) && subtype.priv.paramSpecAccess) {
             return subtype;
         }
         // Place an upper limit on the number of union subtypes we
@@ -1358,7 +1363,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
 // to) the unbounded element.
 function expandUnboundedTupleElement(tupleType, elementsToAdd, keepUnbounded) {
     const tupleTypeArgs = [];
-    tupleType.tupleTypeArguments.forEach((typeArg) => {
+    tupleType.priv.tupleTypeArguments.forEach((typeArg) => {
         if (!typeArg.isUnbounded) {
             tupleTypeArgs.push(typeArg);
         }
@@ -1386,13 +1391,13 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     // with a known length.
     if (!(0, types_1.isClassInstance)(containerType) ||
         !types_1.ClassType.isBuiltIn(containerType, 'tuple') ||
-        !containerType.tupleTypeArguments) {
+        !containerType.priv.tupleTypeArguments) {
         return referenceType;
     }
     // Determine which tuple types can be eliminated. Only "None" and
     // literal types can be handled here.
     const typesToEliminate = [];
-    containerType.tupleTypeArguments.forEach((tupleEntry) => {
+    containerType.priv.tupleTypeArguments.forEach((tupleEntry) => {
         if (!tupleEntry.isUnbounded) {
             if ((0, typeUtils_1.isNoneInstance)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
@@ -1407,7 +1412,7 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     }
     return (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
         referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
-        if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.literalValue === undefined) {
+        if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.priv.literalValue === undefined) {
             // If we're able to enumerate all possible literal values
             // (for bool or enum), we can eliminate all others in a negative test.
             const allLiteralTypes = enumerateLiteralsForType(evaluator, referenceSubtype);
@@ -1427,12 +1432,12 @@ function getElementTypeForContainerNarrowing(containerType) {
     if (!(0, types_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType, supportedContainers)) {
         return undefined;
     }
-    if (!containerType.typeArguments || containerType.typeArguments.length < 1) {
+    if (!containerType.priv.typeArguments || containerType.priv.typeArguments.length < 1) {
         return undefined;
     }
-    let elementType = containerType.typeArguments[0];
-    if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.tupleTypeArguments) {
-        elementType = (0, types_1.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
+    let elementType = containerType.priv.typeArguments[0];
+    if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.priv.tupleTypeArguments) {
+        elementType = (0, types_1.combineTypes)(containerType.priv.tupleTypeArguments.map((t) => t.type));
     }
     return elementType;
 }
@@ -1507,7 +1512,7 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
         }
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
             const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
-            const tdEntry = (_a = entries.knownItems.get(literalKey.literalValue)) !== null && _a !== void 0 ? _a : entries.extraItems;
+            const tdEntry = (_a = entries.knownItems.get(literalKey.priv.literalValue)) !== null && _a !== void 0 ? _a : entries.extraItems;
             if (isPositiveTest) {
                 if (!tdEntry) {
                     return undefined;
@@ -1517,9 +1522,9 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
                 if (tdEntry.isRequired || tdEntry.isProvided) {
                     return subtype;
                 }
-                const newNarrowedEntriesMap = new Map((_b = subtype.typedDictNarrowedEntries) !== null && _b !== void 0 ? _b : []);
+                const newNarrowedEntriesMap = new Map((_b = subtype.priv.typedDictNarrowedEntries) !== null && _b !== void 0 ? _b : []);
                 // Add the new entry.
-                newNarrowedEntriesMap.set(literalKey.literalValue, {
+                newNarrowedEntriesMap.set(literalKey.priv.literalValue, {
                     valueType: tdEntry.valueType,
                     isReadOnly: tdEntry.isReadOnly,
                     isRequired: false,
@@ -1544,7 +1549,7 @@ function narrowTypeForDiscriminatedDictEntryComparison(evaluator, referenceType,
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
             const symbolMap = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype);
-            const tdEntry = symbolMap.knownItems.get(indexLiteralType.literalValue);
+            const tdEntry = symbolMap.knownItems.get(indexLiteralType.priv.literalValue);
             if (tdEntry && (0, typeUtils_1.isLiteralTypeOrUnion)(tdEntry.valueType)) {
                 if (isPositiveTest) {
                     let foundMatch = false;
@@ -1579,11 +1584,13 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
         if ((0, types_1.isClassInstance)(subtype) &&
             types_1.ClassType.isTupleClass(subtype) &&
             !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
-            typeof indexLiteralType.literalValue === 'number' &&
+            typeof indexLiteralType.priv.literalValue === 'number' &&
             (0, types_1.isClassInstance)(literalType)) {
-            const indexValue = indexLiteralType.literalValue;
-            if (subtype.tupleTypeArguments && indexValue >= 0 && indexValue < subtype.tupleTypeArguments.length) {
-                const tupleEntryType = (_a = subtype.tupleTypeArguments[indexValue]) === null || _a === void 0 ? void 0 : _a.type;
+            const indexValue = indexLiteralType.priv.literalValue;
+            if (subtype.priv.tupleTypeArguments &&
+                indexValue >= 0 &&
+                indexValue < subtype.priv.tupleTypeArguments.length) {
+                const tupleEntryType = (_a = subtype.priv.tupleTypeArguments[indexValue]) === null || _a === void 0 ? void 0 : _a.type;
                 if (tupleEntryType && (0, typeUtils_1.isLiteralTypeOrUnion)(tupleEntryType)) {
                     if (isPositiveTest) {
                         return evaluator.assignType(tupleEntryType, literalType) ? subtype : undefined;
@@ -1618,8 +1625,8 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
             // Handle the case where the field is a property
             // that has a declared literal return type for its getter.
             if ((0, types_1.isClassInstance)(subtype) && (0, types_1.isClassInstance)(memberType) && (0, typeUtils_1.isProperty)(memberType)) {
-                const getterType = (_a = memberType.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType;
-                if (getterType && getterType.details.declaredReturnType) {
+                const getterType = (_a = memberType.priv.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType;
+                if (getterType && getterType.shared.declaredReturnType) {
                     const getterReturnType = types_1.FunctionType.getEffectiveReturnType(getterType);
                     if (getterReturnType) {
                         memberType = getterReturnType;
@@ -1681,6 +1688,7 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
 function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
     return evaluator.mapSubtypesExpandTypeVars(type, 
     /* options */ undefined, (subtype, unexpandedSubtype) => {
+        var _a;
         if ((0, types_1.isClassInstance)(subtype)) {
             const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
             if (isPositiveTest) {
@@ -1688,13 +1696,13 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
                     if (types_1.ClassType.isSameGenericClass(subtype, classType)) {
                         return subtype;
                     }
-                    return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), subtype.condition);
+                    return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
                 }
-                if (!classType.includeSubclasses) {
+                if (!classType.priv.includeSubclasses) {
                     return undefined;
                 }
             }
-            else if (!classType.includeSubclasses) {
+            else if (!classType.priv.includeSubclasses) {
                 // If the class if marked final and it matches, then
                 // we can eliminate it in the negative case.
                 if (matches && types_1.ClassType.isFinal(subtype)) {
@@ -1728,8 +1736,8 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
                 types_1.TypeBase.isInstance(subtype) &&
                 types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
                 concreteSubtype =
-                    concreteSubtype.typeArguments && concreteSubtype.typeArguments.length > 0
-                        ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.typeArguments[0])
+                    concreteSubtype.priv.typeArguments && concreteSubtype.priv.typeArguments.length > 0
+                        ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.priv.typeArguments[0])
                         : types_1.UnknownType.create();
             }
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
@@ -1741,11 +1749,11 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
                 }
                 const isSuperType = isIsinstanceFilterSuperclass(evaluator, subtype, concreteSubtype, classType, classType, 
                 /* isInstanceCheck */ false);
-                if (!classType.includeSubclasses) {
+                if (!classType.priv.includeSubclasses) {
                     // Handle the case where the LHS and RHS operands are specific
                     // classes, as opposed to types that represent classes and their
                     // subclasses.
-                    if (!concreteSubtype.includeSubclasses) {
+                    if (!concreteSubtype.priv.includeSubclasses) {
                         return types_1.ClassType.isSameGenericClass(concreteSubtype, classType) ? classType : undefined;
                     }
                     const isSubType = isIsinstanceFilterSubclass(evaluator, concreteSubtype, classType, 
@@ -1786,7 +1794,7 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
             return subtype;
         }
         else if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
-            if (subtype.literalValue !== undefined) {
+            if (subtype.priv.literalValue !== undefined) {
                 const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
                 if ((literalValueMatches && !isPositiveTest) || (!literalValueMatches && isPositiveTest)) {
                     return undefined;
@@ -1825,7 +1833,7 @@ function enumerateLiteralsForType(evaluator, type) {
     if (types_1.ClassType.isEnumClass(type)) {
         // Enum expansion doesn't apply to enum classes that derive
         // from enum.Flag.
-        if (type.details.baseClasses.some((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'Flag'))) {
+        if (type.shared.baseClasses.some((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'Flag'))) {
             return undefined;
         }
         // Enumerate all of the values in this enumeration.
@@ -1838,7 +1846,7 @@ function enumerateLiteralsForType(evaluator, type) {
                 symbolType = (_a = (0, enums_1.transformTypeForEnumMember)(evaluator, type, name)) !== null && _a !== void 0 ? _a : symbolType;
                 if ((0, types_1.isClassInstance)(symbolType) &&
                     types_1.ClassType.isSameGenericClass(type, symbolType) &&
-                    symbolType.literalValue !== undefined) {
+                    symbolType.priv.literalValue !== undefined) {
                     enumList.push(symbolType);
                 }
             }
@@ -1854,6 +1862,7 @@ exports.enumerateLiteralsForType = enumerateLiteralsForType;
 // it's not callable.
 function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allowIntersections) {
     return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
+        var _a;
         switch (subtype.category) {
             case 4 /* TypeCategory.Function */:
             case 5 /* TypeCategory.OverloadedFunction */: {
@@ -1879,24 +1888,19 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                         // The type appears to not be callable. It's possible that the
                         // two type is a subclass that is callable. We'll synthesize a
                         // new intersection type.
-                        const className = `<callable subtype of ${subtype.details.name}>`;
+                        const className = `<callable subtype of ${subtype.shared.name}>`;
                         const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
                         let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
-                        /* declaredMetaclass */ undefined, subtype.details.effectiveMetaclass, subtype.details.docString);
-                        newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
+                        /* declaredMetaclass */ undefined, subtype.shared.effectiveMetaclass, subtype.shared.docString);
+                        newClassType.shared.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
                         (0, typeUtils_1.computeMroLinearization)(newClassType);
-                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, subtype.condition);
+                        newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
                         // Add a __call__ method to the new class.
                         const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
-                        const selfParam = {
-                            category: 0 /* ParameterCategory.Simple */,
-                            name: 'self',
-                            type: types_1.ClassType.cloneAsInstance(newClassType),
-                            hasDeclaredType: true,
-                        };
+                        const selfParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(newClassType), types_1.FunctionParamFlags.TypeDeclared, 'self');
                         types_1.FunctionType.addParameter(callMethod, selfParam);
                         types_1.FunctionType.addDefaultParameters(callMethod);
-                        callMethod.details.declaredReturnType = types_1.UnknownType.create();
+                        callMethod.shared.declaredReturnType = types_1.UnknownType.create();
                         types_1.ClassType.getSymbolTable(newClassType).set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, callMethod));
                         return types_1.ClassType.cloneAsInstance(newClassType);
                     }