@zzzen/pyright-internal 1.2.0-dev.20261018 → 1.2.0-dev.20261101

package/dist/tests/typeEvaluator8.test.js

@@ -43,7 +43,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert = __importStar(require("assert"));
+const constraintSolution_1 = require("../analyzer/constraintSolution");
+const TupleComparison = __importStar(require("../analyzer/tupleComparison"));
 const types_1 = require("../analyzer/types");
+const typeUtils_1 = require("../analyzer/typeUtils");
 const configOptions_1 = require("../common/configOptions");
 const diagnosticRules_1 = require("../common/diagnosticRules");
 const pythonVersion_1 = require("../common/pythonVersion");
@@ -445,7 +448,7 @@ test('Tuple10', () => {
 });
 test('Tuple11', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tuple11.py']);
-    TestUtils.validateResults(analysisResults, 1);
+    TestUtils.validateResults(analysisResults, 3);
 });
 test('Tuple12', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tuple12.py']);
@@ -520,6 +523,61 @@ test('NamedTuple11', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['namedTuple11.py']);
     TestUtils.validateResults(analysisResults, 3);
 });
+test('NamedTupleReplace1', () => {
+    const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
+    configOptions.defaultPythonVersion = pythonVersion_1.pythonVersion3_12;
+    const analysisResults1 = TestUtils.typeAnalyzeSampleFiles(['namedTupleReplace1.py'], configOptions);
+    TestUtils.validateResults(analysisResults1, 8);
+    configOptions.defaultPythonVersion = pythonVersion_1.pythonVersion3_13;
+    const analysisResults2 = TestUtils.typeAnalyzeSampleFiles(['namedTupleReplace1.py'], configOptions);
+    TestUtils.validateResults(analysisResults2, 8);
+});
+test('NamedTupleReplace2', () => {
+    const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
+    configOptions.defaultPythonVersion = pythonVersion_1.pythonVersion3_12;
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['namedTupleReplace2.py'], configOptions);
+    TestUtils.validateResults(analysisResults, 0);
+});
+test('NamedTupleReplace3', () => {
+    for (const pythonVersion of [pythonVersion_1.pythonVersion3_12, pythonVersion_1.pythonVersion3_13]) {
+        const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
+        configOptions.defaultPythonVersion = pythonVersion;
+        const analysisResults = TestUtils.typeAnalyzeSampleFiles(['namedTupleReplace3.py'], configOptions);
+        TestUtils.validateResults(analysisResults, 2);
+        assert.deepStrictEqual(analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), [
+            [15, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+            [54, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        ]);
+    }
+});
+test('NamedTupleReplace4', () => {
+    for (const pythonVersion of [pythonVersion_1.pythonVersion3_12, pythonVersion_1.pythonVersion3_13]) {
+        const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
+        configOptions.defaultPythonVersion = pythonVersion;
+        const analysisResults = TestUtils.typeAnalyzeSampleFiles(['namedTupleReplace4.py'], configOptions);
+        const expectedErrors = [
+            [25, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+            [28, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        ];
+        if (pythonVersion === pythonVersion_1.pythonVersion3_13) {
+            expectedErrors.push([35, diagnosticRules_1.DiagnosticRule.reportArgumentType], [38, diagnosticRules_1.DiagnosticRule.reportArgumentType]);
+        }
+        TestUtils.validateResults(analysisResults, expectedErrors.length);
+        assert.deepStrictEqual(analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), expectedErrors);
+    }
+});
+test('NamedTupleReplace5', () => {
+    for (const pythonVersion of [pythonVersion_1.pythonVersion3_12, pythonVersion_1.pythonVersion3_13]) {
+        const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
+        configOptions.defaultPythonVersion = pythonVersion;
+        const analysisResults = TestUtils.typeAnalyzeSampleFiles(['namedTupleReplace5.py'], configOptions);
+        TestUtils.validateResults(analysisResults, 2);
+        assert.deepStrictEqual(analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), [
+            [19, diagnosticRules_1.DiagnosticRule.reportReturnType],
+            [28, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        ]);
+    }
+});
 test('NamedTuple12', () => {
     const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
     configOptions.defaultPythonVersion = pythonVersion_1.pythonVersion3_12;
@@ -660,6 +718,73 @@ test('Descriptor7', () => {
         [134, diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue],
     ]);
 });
+test('MethodDescriptor1', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor1.py']);
+    TestUtils.validateResults(analysisResults, 0);
+});
+test('MethodDescriptor2', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor2.py']);
+    TestUtils.validateResults(analysisResults, 0);
+});
+test('MethodDescriptor3', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor3.py']);
+    TestUtils.validateResults(analysisResults, 4);
+    const errors = [...analysisResults[0].errors].sort((a, b) => a.range.start.line - b.range.start.line);
+    assert.deepStrictEqual(errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), [
+        [14, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        [17, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [20, diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue],
+        [24, diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess],
+    ]);
+    assert.match(errors[2].message, /Cannot assign to attribute "__func__"/);
+});
+test('MethodDescriptor4', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor4.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    analysisResults[0].errors.forEach((diagnostic) => assert.strictEqual(diagnostic.getRule(), diagnosticRules_1.DiagnosticRule.reportAssignmentType));
+});
+test('MethodDescriptor5', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor5.py']);
+    TestUtils.validateResults(analysisResults, 15);
+    const errors = [...analysisResults[0].errors].sort((a, b) => a.range.start.line - b.range.start.line);
+    assert.deepStrictEqual(errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]).sort(), [
+        [31, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [40, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        [49, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [50, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        [61, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [73, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues],
+        [73, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues],
+        [74, diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess],
+        [74, diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue],
+        [74, diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess],
+        [75, diagnosticRules_1.DiagnosticRule.reportOperatorIssue],
+        [75, diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess],
+        [83, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [94, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [104, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+    ].sort());
+});
+test('MethodDescriptor6', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor6.py']);
+    TestUtils.validateResults(analysisResults, 1);
+    assert.strictEqual(analysisResults[0].errors[0].getRule(), diagnosticRules_1.DiagnosticRule.reportOperatorIssue);
+});
+test('MethodDescriptor7', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodDescriptor7.py']);
+    TestUtils.validateResults(analysisResults, 9);
+    assert.deepStrictEqual(analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]).sort(), [
+        [36, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [62, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [84, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        [84, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [85, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [86, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        [103, diagnosticRules_1.DiagnosticRule.reportCallIssue],
+        [103, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [114, diagnosticRules_1.DiagnosticRule.reportInconsistentOverload],
+    ].sort());
+});
 test('Partial1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['partial1.py']);
     TestUtils.validateResults(analysisResults, 18);
@@ -1169,4 +1294,1169 @@ test('TypeForm9', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typeForm9.py']);
     TestUtils.validateResults(analysisResults, 10);
 });
+test('TupleComparisonResults1', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults1.py']);
+    TestUtils.validateResults(analysisResults, 18);
+});
+test('TupleLiteralInference1', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference1.py']);
+    TestUtils.validateResults(analysisResults, 2);
+});
+test('TupleLiteralInference2', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference2.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+});
+test('TupleLiteralInference3', () => {
+    const comparisonSpy = jest.spyOn(TupleComparison, 'getTupleComparisonResult');
+    try {
+        const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference3.py']);
+        TestUtils.validateResults(analysisResults, 0);
+        assert.ok(comparisonSpy.mock.calls.length > 0);
+        const callsByNode = new Map();
+        comparisonSpy.mock.calls.forEach(([, , , , node]) => {
+            const calls = (callsByNode.get(node.id) ?? 0) + 1;
+            callsByNode.set(node.id, calls);
+            assert.ok(calls <= types_1.maxSubtypesForInferredType, 'Optional tuple precision exceeded the comparison budget');
+        });
+    }
+    finally {
+        comparisonSpy.mockRestore();
+    }
+});
+test('TupleLiteralInference4', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference4.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [114, 123]);
+});
+test('TupleLiteralInference5', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference5.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [80, 89]);
+});
+test('TupleComparisonResults2', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults2.py']);
+    TestUtils.validateResults(analysisResults, 0);
+});
+test('TupleComparisonResults3', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults3.py']);
+    TestUtils.validateResults(analysisResults, 0);
+});
+test('TupleComparisonResults4', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults4.py']);
+    TestUtils.validateResults(analysisResults, 16);
+});
+test('TupleComparisonResults5', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults5.py']);
+    TestUtils.validateResults(analysisResults, 0);
+});
+test('TupleComparisonResults6', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles([
+        'tupleComparisonResource_hierarchy_64.py',
+        'tupleComparisonResource_hierarchy_128.py',
+        'tupleComparisonResource_hierarchy_256.py',
+        'tupleComparisonResource_literal_union.py',
+        'tupleComparisonResource_bool_union.py',
+        'tupleComparisonResource_mixed_union.py',
+        'tupleComparisonResource_mixed_union_consumer.py',
+        'tupleComparisonResource_unsupported_union.py',
+        'tupleComparisonResource_narrow_argument_union.py',
+        'tupleComparisonResource_nested_tuple.py',
+        'tupleComparisonResource_nested_list.py',
+        'tupleComparisonResource_repeated_nested_types.py',
+        'tupleComparisonResource_recursive_container.py',
+        'tupleComparisonResource_recursive_nonbool.py',
+        'tupleComparisonResource_recursive_bad_consumer.py',
+        'tupleComparisonResource_long_alias_chain.py',
+        'tupleComparisonResource_cyclic_source.py',
+        'tupleComparisonResource_growing_alias_lt.py',
+        'tupleComparisonResource_growing_alias_le.py',
+        'tupleComparisonResource_growing_alias_gt.py',
+        'tupleComparisonResource_growing_alias_ge.py',
+        'tupleComparisonResource_growing_custom_bool.py',
+        'tupleComparisonResource_growing_custom_str.py',
+        'tupleComparisonResource_growing_two_parameters.py',
+        'tupleComparisonResource_literal_boolean_result.py',
+        'tupleComparisonResource_large_variadic_suffix.py',
+        'tupleComparisonResource_large_variadic_custom.py',
+        'tupleComparisonResource_large_variadic_nonbool.py',
+        'tupleComparisonResource_one_sided_variadic.py',
+        'tupleComparisonResource_deep_nonbool.py',
+    ]);
+    const expectedErrors = [0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    analysisResults.forEach((result, index) => TestUtils.validateResults([result], expectedErrors[index]));
+});
+test('TupleComparisonResults7', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults7.py']);
+    TestUtils.validateResults(analysisResults, 28);
+});
+test('TupleComparisonResults8', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults8.py']);
+    TestUtils.validateResults(analysisResults, 1);
+});
+test('TupleComparisonResults9', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults9.py']);
+    TestUtils.validateResults(analysisResults, 12);
+});
+test('TupleComparisonResults10', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults10.py']);
+    TestUtils.validateResults(analysisResults, 7);
+});
+test('TupleComparisonResults11', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults11.py']);
+    TestUtils.validateResults(analysisResults, 7);
+    assert.strictEqual(analysisResults[0].errors.filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportReturnType).length, 4);
+    assert.strictEqual(analysisResults[0].errors.filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportOperatorIssue).length, 3);
+});
+test('TupleComparisonResults12', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults12.py']);
+    TestUtils.validateResults(analysisResults, 1);
+    assert.strictEqual(analysisResults[0].errors[0].getRule(), diagnosticRules_1.DiagnosticRule.reportOperatorIssue);
+    assert.strictEqual(analysisResults[0].errors[0].range.start.line + 1, 84);
+});
+test('TupleComparisonResults13', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults13.py']);
+    TestUtils.validateResults(analysisResults, 10);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportReturnType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [49, 53, 57, 61, 65, 69, 73, 77, 81, 85]);
+});
+test('TupleLiteralInference6', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference6.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [35, 44]);
+});
+test('TupleLiteralInferenceRetentionBudget', () => {
+    const state = (0, testState_1.parseAndGetTestState)('// @filename: test.py\n//// /*marker*/0').state;
+    const evaluator = state.program.evaluator;
+    const node = (0, testState_1.getNodeAtMarker)(state, 'marker');
+    const intType = evaluator.getBuiltInObject(node, 'int');
+    const tupleClass = evaluator.getTupleClassType();
+    assert.ok(tupleClass && (0, types_1.isInstantiableClass)(tupleClass));
+    const buildGraph = () => {
+        const types = [];
+        let type = intType;
+        for (let depth = 0; depth < 16; depth++) {
+            const tuple = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(tupleClass, [type], true, false, [
+                { type, isUnbounded: false },
+                { type, isUnbounded: false },
+            ]));
+            types.push(tuple);
+            type = tuple;
+        }
+        return types;
+    };
+    const types = buildGraph();
+    const baseTypes = buildGraph();
+    const type = types[types.length - 1];
+    const baseType = baseTypes[baseTypes.length - 1];
+    let reads = 0;
+    baseTypes.forEach((type) => {
+        const args = type.priv.tupleTypeArgs;
+        Object.defineProperty(type.priv, 'tupleTypeArgs', {
+            get: () => {
+                reads++;
+                return args;
+            },
+        });
+    });
+    assert.strictEqual((0, types_1.retainInferredTupleLiterals)(type, baseType), baseType);
+    assert.strictEqual(reads, 0, 'Over-budget retention should fall back before comparing the base graph');
+});
+test('TupleComparisonResults14', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults14.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [118, 119]);
+});
+test('TupleComparisonResults15', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults15.py']);
+    TestUtils.validateResults(analysisResults, 2);
+    assert.strictEqual(analysisResults[0].errors.filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportReturnType).length, 1);
+    assert.strictEqual(analysisResults[0].errors.filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportOperatorIssue).length, 1);
+    assert.deepStrictEqual(analysisResults[0].errors
+        .slice()
+        .sort((left, right) => left.range.start.line - right.range.start.line)
+        .map((diag) => [diag.range.start.line + 1, diag.getRule()]), [
+        [41, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        [45, diagnosticRules_1.DiagnosticRule.reportOperatorIssue],
+    ]);
+});
+test('TupleComparisonEqualityMemoization', () => {
+    const code = `// @filename: test.py
+//// /*marker*/0
+`;
+    const state = (0, testState_1.parseAndGetTestState)(code).state;
+    const evaluator = state.program.evaluator;
+    const node = (0, testState_1.getNodeAtMarker)(state, 'marker');
+    assert.ok(node.nodeType === 40 /* ParseNodeType.Number */);
+    const intType = evaluator.getBuiltInObject(node, 'int');
+    const boolType = evaluator.getBuiltInObject(node, 'bool');
+    const tupleClass = evaluator.getTupleClassType();
+    assert.ok(tupleClass && (0, types_1.isInstantiableClass)(tupleClass));
+    let type = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(tupleClass, [intType], true, false, [{ type: intType, isUnbounded: false }]));
+    const types = [type];
+    for (let depth = 1; depth <= 16; depth++) {
+        type = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(tupleClass, [type], true, false, [
+            { type, isUnbounded: false },
+            { type, isUnbounded: false },
+        ]));
+        types.push(type);
+    }
+    let reads = 0;
+    types.forEach((type) => {
+        const args = type.priv.tupleTypeArgs;
+        Object.defineProperty(type.priv, 'tupleTypeArgs', {
+            get: () => {
+                reads++;
+                return args;
+            },
+        });
+    });
+    const result = TupleComparison.getTupleComparisonResult(evaluator, type, type, 20 /* OperatorType.LessThan */, node);
+    assert.ok(result && (0, types_1.isTypeSame)(result.type, boolType));
+    assert.ok(reads < 1000, `Shared tuple graph was repeatedly expanded (${reads} tuple-argument reads)`);
+});
+test('TupleComparisonResults16', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults16.py']);
+    TestUtils.validateResults(analysisResults, 6);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [112, 113, 114, 115, 116, 117]);
+});
+test('TupleComparisonResults17', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults17.py']);
+    TestUtils.validateResults(analysisResults, 8);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [82, 83, 84, 85, 96, 97, 98, 99]);
+});
+test('TupleComparisonDistinctEqualityMemoization', () => {
+    const lines = ['// @filename: test.py', '////type L0 = tuple[int]', '////type R0 = tuple[int]'];
+    for (let depth = 1; depth <= 16; depth++) {
+        lines.push(`////type L${depth} = tuple[L${depth - 1}, L${depth - 1}]`);
+        lines.push(`////type R${depth} = tuple[R${depth - 1}, R${depth - 1}]`);
+    }
+    lines.push('////def compare(left: L16, right: R16) -> bool:');
+    lines.push('////    return /*left*/left < /*right*/right');
+    const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+    const evaluator = state.program.evaluator;
+    const leftNode = (0, testState_1.getNodeAtMarker)(state, 'left');
+    const rightNode = (0, testState_1.getNodeAtMarker)(state, 'right');
+    assert.ok(leftNode.nodeType === 38 /* ParseNodeType.Name */ && rightNode.nodeType === 38 /* ParseNodeType.Name */);
+    const left = evaluator.getTypeOfExpression(leftNode).type;
+    const right = evaluator.getTypeOfExpression(rightNode).type;
+    assert.ok((0, types_1.isClassInstance)(left) && (0, types_1.isClassInstance)(right));
+    assert.notStrictEqual(left, right);
+    assert.notStrictEqual(left.priv.tupleTypeArgs?.[0].type, right.priv.tupleTypeArgs?.[0].type);
+    const types = new Set();
+    const visit = (type) => {
+        if (!(0, types_1.isClassInstance)(type) || !type.priv.tupleTypeArgs || types.has(type.priv))
+            return;
+        types.add(type.priv);
+        type.priv.tupleTypeArgs.forEach((arg) => visit(arg.type));
+    };
+    visit(left);
+    visit(right);
+    let reads = 0;
+    types.forEach((priv) => {
+        const args = priv.tupleTypeArgs;
+        Object.defineProperty(priv, 'tupleTypeArgs', {
+            get: () => {
+                reads++;
+                return args;
+            },
+        });
+    });
+    const node = leftNode.parent;
+    assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+    const result = evaluator.getTypeOfExpression(node);
+    assert.ok((0, types_1.isTypeSame)(result.type, evaluator.getBuiltInObject(node, 'bool')));
+    assert.ok(reads > 0 && reads < 1000, `Distinct tuple graphs were repeatedly expanded (${reads} tuple-argument reads)`);
+});
+test('TupleComparisonResults18', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults18.py']);
+    TestUtils.validateResults(analysisResults, 6);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [115, 116, 117, 118, 119, 120]);
+});
+test('TupleComparisonResults19', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults19.py']);
+    TestUtils.validateResults(analysisResults, 4);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [46, 47, 48, 49]);
+});
+test('TupleComparisonResults20', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults20.py']);
+    TestUtils.validateResults(analysisResults, 4);
+    analysisResults[0].errors.forEach((diag) => assert.strictEqual(diag.getRule(), diagnosticRules_1.DiagnosticRule.reportArgumentType));
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => diag.range.start.line + 1).sort((left, right) => left - right), [49, 50, 51, 52]);
+});
+test('TupleComparisonResults24', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults24.py']);
+    TestUtils.validateResults(analysisResults, 14);
+    assert.deepStrictEqual(analysisResults[0].errors
+        .slice()
+        .sort((left, right) => left.range.start.line - right.range.start.line)
+        .map((diag) => [diag.range.start.line + 1, diag.getRule()]), [
+        [34, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [35, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [36, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [37, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [42, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        [47, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        [52, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        [57, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        [87, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [88, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [89, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [90, diagnosticRules_1.DiagnosticRule.reportArgumentType],
+        [111, diagnosticRules_1.DiagnosticRule.reportReturnType],
+        [117, diagnosticRules_1.DiagnosticRule.reportReturnType],
+    ]);
+});
+for (const context of ['chained', 'parenthesized']) {
+    for (const form of ['tuple', 'name']) {
+        for (const operator of ['<', '<=', '>', '>=']) {
+            test(`TupleComparisonChainedIdentity ${context} ${form} ${operator}`, () => {
+                const left = form === 'tuple' ? '(/*middle*/value, 0)' : '/*middle*/pair';
+                const right = form === 'tuple' ? '(value, 1)' : 'pair';
+                const comparison = `${left} ${operator} ${right}`;
+                const expression = context === 'chained' ? `(Rebind(),) < ${comparison}` : `0 < (${comparison})`;
+                const lines = [
+                    '// @filename: test.py',
+                    '////class Value:',
+                    ...['__lt__', '__le__', '__gt__', '__ge__'].flatMap((method) => [
+                        `////    def ${method}(self, other: object) -> str:`,
+                        '////        return "ordered"',
+                    ]),
+                    '////value = Value()',
+                    '////pair: tuple[Value, int] = (value, 0)',
+                    '////class Rebind:',
+                    '////    def __lt__(self, other: object) -> bool:',
+                    '////        global value, pair',
+                    '////        value = Value()',
+                    '////        pair = (value, 1)',
+                    '////        return True',
+                    '////def compare() -> None:',
+                    `////    _ = ${expression}`,
+                ];
+                const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+                const evaluator = state.program.evaluator;
+                const marker = (0, testState_1.getNodeAtMarker)(state, 'middle');
+                assert.ok(marker.nodeType === 38 /* ParseNodeType.Name */);
+                const node = form === 'tuple' ? marker.parent?.parent : marker.parent;
+                assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+                // Whole-chain propagation can hide the child result; inspect the actual comparison node.
+                const result = evaluator.getTypeOfExpression(node);
+                const boolType = evaluator.getBuiltInObject(node, 'bool');
+                const expected = context === 'chained'
+                    ? (0, types_1.combineTypes)([evaluator.getBuiltInObject(node, 'str'), boolType])
+                    : boolType;
+                assert.ok((0, types_1.isTypeSame)(result.type, expected), 'The complete middle-comparison type must be preserved');
+                assert.strictEqual(evaluator.assignType(boolType, result.type), context !== 'chained');
+            });
+        }
+    }
+}
+test('TupleComparisonClosedResultWorkBound', () => {
+    for (const shape of ['below', 'limit', 'over', 'open', 'depth', 'deep', 'never']) {
+        const code = `// @filename: test.py
+////class /*value*/Value[T]:
+////    def __lt__(self, other: object) -> str:
+////        return "ordered"
+////type Tree[T] = tuple[Value[T], tuple[Tree[list[T]], ...]]
+////def compare(left: Tree[int], right: Tree[int]) -> None:
+////    /*compare*/left < right
+`;
+        const state = (0, testState_1.parseAndGetTestState)(code).state;
+        const evaluator = state.program.evaluator;
+        const node = (0, testState_1.getNodeAtMarker)(state, 'compare').parent;
+        assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+        const strType = evaluator.getBuiltInObject(node, 'str');
+        const boolType = evaluator.getBuiltInObject(node, 'bool');
+        const listType = evaluator.getBuiltInObject(node, 'list');
+        const tupleClass = evaluator.getTupleClassType();
+        assert.ok((0, types_1.isClassInstance)(listType) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass));
+        let payload = strType;
+        let reads = 0;
+        if (shape === 'never') {
+            payload = types_1.ClassType.specialize(listType, [types_1.NeverType.createNever()], true);
+        }
+        else if (shape === 'open') {
+            const valueNode = (0, testState_1.getNodeAtMarker)(state, 'value');
+            assert.ok(valueNode.nodeType === 38 /* ParseNodeType.Name */);
+            const valueClass = evaluator.getTypeOfExpression(valueNode).type;
+            assert.ok((0, types_1.isInstantiableClass)(valueClass) && valueClass.shared.typeParams.length === 1);
+            payload = types_1.ClassType.specialize(listType, [valueClass.shared.typeParams[0]], true);
+        }
+        else if (shape === 'depth' || shape === 'deep') {
+            const depth = types_1.maxTypeRecursionCount + (shape === 'deep' ? 1 : 0);
+            for (let index = 0; index < depth; index++) {
+                payload = types_1.ClassType.specialize(listType, [payload], true);
+            }
+        }
+        else {
+            const width = types_1.maxSubtypesForInferredType - (shape === 'below' ? 2 : shape === 'limit' ? 1 : 0);
+            const args = Array.from({ length: width }, () => {
+                const arg = { type: strType, isUnbounded: false };
+                Object.defineProperty(arg, 'type', {
+                    get: () => {
+                        reads++;
+                        return strType;
+                    },
+                });
+                return arg;
+            });
+            payload = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(tupleClass, [strType], true, false, args));
+        }
+        const originalCall = evaluator.getTypeOfMagicMethodCall;
+        const originalExpand = evaluator.mapSubtypesExpandTypeVars;
+        let expansions = 0;
+        evaluator.getTypeOfMagicMethodCall = (...args) => (0, types_1.isClassInstance)(args[0]) && args[0].shared.name === 'Value' ? { type: payload } : originalCall(...args);
+        evaluator.mapSubtypesExpandTypeVars = (...args) => {
+            assert.ok(++expansions <= 2 * (types_1.maxSubtypesForInferredType + 1), `Unbounded expansion (${shape})`);
+            return originalExpand(...args);
+        };
+        try {
+            reads = 0;
+            const result = evaluator.getTypeOfExpression(node);
+            assert.ok(expansions > 0);
+            assert.ok(reads <= types_1.maxSubtypesForInferredType, `Unbounded result traversal (${shape}: ${reads})`);
+            if (shape === 'over' || shape === 'open' || shape === 'deep') {
+                assert.ok((0, types_1.isTypeSame)(result.type, boolType), `Complex result should use the existing fallback (${shape})`);
+            }
+            else {
+                if (shape !== 'depth' && shape !== 'never')
+                    assert.ok(reads > 0);
+                assert.ok((0, types_1.isTypeSame)(result.type, (0, types_1.combineTypes)([payload, boolType])), `Closed result should preserve exactly payload | bool (${shape})`);
+            }
+        }
+        finally {
+            evaluator.getTypeOfMagicMethodCall = originalCall;
+            evaluator.mapSubtypesExpandTypeVars = originalExpand;
+        }
+    }
+});
+test('TupleComparisonGrowingWorkBound', () => {
+    for (const parameters of ['T', 'T, T']) {
+        const lines = [
+            '// @filename: test.py',
+            `////class Box[${parameters === 'T' ? 'T' : 'T, U'}]:`,
+            ...['__lt__', '__le__', '__gt__', '__ge__'].flatMap((method) => [
+                `////    def ${method}(self, other: object) -> str:`,
+                '////        return "ordered"',
+            ]),
+            `////type Tree[T] = tuple[T, tuple[Tree[Box[${parameters}]], ...]]`,
+            '////def compare(left: Tree[int], right: Tree[int]) -> None:',
+            ...['<', '<=', '>', '>='].map((operator, index) => `////    /*op${index}*/left ${operator} right`),
+        ];
+        const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+        const evaluator = state.program.evaluator;
+        const original = evaluator.mapSubtypesExpandTypeVars;
+        let visits = 0;
+        evaluator.mapSubtypesExpandTypeVars = (...args) => {
+            assert.ok(++visits <= 64, `Recursive tuple ordering exceeded 64 type-expansion visits (${parameters})`);
+            return original(...args);
+        };
+        try {
+            for (let index = 0; index < 4; index++) {
+                visits = 0;
+                const node = (0, testState_1.getNodeAtMarker)(state, `op${index}`).parent;
+                assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+                const result = evaluator.getTypeOfExpression(node);
+                assert.ok(visits > 0);
+                assert.ok((0, types_1.isTypeSame)(result.type, (0, types_1.combineTypes)([
+                    evaluator.getBuiltInObject(node, 'str'),
+                    evaluator.getBuiltInObject(node, 'bool'),
+                ])));
+            }
+        }
+        finally {
+            evaluator.mapSubtypesExpandTypeVars = original;
+        }
+    }
+});
+test('TupleComparisonAliasSpecializationBound', () => {
+    const lines = [
+        '// @filename: test.py',
+        '////type Tree[T] = tuple[int, tuple[Tree[list[T]], ...]]',
+        '////def compare(left: Tree[int], right: Tree[int]) -> None:',
+        ...['<', '<=', '>', '>='].map((operator, index) => `////    /*op${index}*/left ${operator} right`),
+    ];
+    const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+    const evaluator = state.program.evaluator;
+    const original = evaluator.mapSubtypesExpandTypeVars;
+    let visits = 0;
+    evaluator.mapSubtypesExpandTypeVars = (...args) => {
+        if ((0, types_1.getTypeAliasInfo)(args[0])?.shared.name === 'Tree') {
+            assert.ok(++visits <= 2 * (types_1.maxSubtypesForInferredType + 1), `Recursive aliases exceeded 64 specializations (${visits} operand expansions)`);
+        }
+        return original(...args);
+    };
+    try {
+        for (let index = 0; index < 4; index++) {
+            visits = 0;
+            const node = (0, testState_1.getNodeAtMarker)(state, `op${index}`).parent;
+            assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+            const result = evaluator.getTypeOfExpression(node);
+            assert.ok(visits > 0);
+            assert.ok((0, types_1.isTypeSame)(result.type, evaluator.getBuiltInObject(node, 'bool')));
+        }
+    }
+    finally {
+        evaluator.mapSubtypesExpandTypeVars = original;
+    }
+});
+test('TupleComparisonHomogeneousVariadicWorkBound', () => {
+    const methods = ['__lt__', '__le__', '__gt__', '__ge__'];
+    const lines = [
+        '// @filename: test.py',
+        '////class Value:',
+        ...methods.flatMap((method) => [
+            `////    def ${method}(self, other: object) -> str:`,
+            '////        return "ordered"',
+        ]),
+        `////type Values = tuple[*tuple[Value, ...], ${Array(32).fill('Value').join(', ')}]`,
+        '////def compare(left: Values, right: Values) -> None:',
+        ...['<', '<=', '>', '>='].map((operator, index) => `////    /*op${index}*/left ${operator} right`),
+    ];
+    const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+    const evaluator = state.program.evaluator;
+    const original = evaluator.getTypeOfMagicMethodCall;
+    let calls = 0;
+    evaluator.getTypeOfMagicMethodCall = (...args) => {
+        calls++;
+        return original(...args);
+    };
+    try {
+        for (let index = 0; index < 4; index++) {
+            calls = 0;
+            const node = (0, testState_1.getNodeAtMarker)(state, `op${index}`).parent;
+            assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+            const result = evaluator.getTypeOfExpression(node);
+            assert.ok(calls > 0 && calls <= types_1.maxSubtypesForInferredType, `Homogeneous pairs required ${calls} calls`);
+            assert.ok((0, types_1.isTypeSame)(result.type, (0, types_1.combineTypes)([evaluator.getBuiltInObject(node, 'str'), evaluator.getBuiltInObject(node, 'bool')])));
+        }
+    }
+    finally {
+        evaluator.getTypeOfMagicMethodCall = original;
+    }
+});
+test('TupleLiteralInferenceScalarOrderingWorkBound', () => {
+    const lines = [
+        '// @filename: test.py',
+        '////def compare(index: int) -> None:',
+        '////    choices = ((0, 1, 2, 3, 4, 5, 6, 7),)[0]',
+        '////    left = choices[index]',
+        '////    right = choices[index]',
+        ...['<', '<=', '>', '>='].map((operator, index) => `////    /*op${index}*/left ${operator} right`),
+    ];
+    const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+    const evaluator = state.program.evaluator;
+    const original = evaluator.getTypeOfMagicMethodCall;
+    for (let index = 0; index < 4; index++) {
+        const node = (0, testState_1.getNodeAtMarker)(state, `op${index}`).parent;
+        assert.ok(node?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+        const left = evaluator.getTypeOfExpression(node.d.leftExpr).type;
+        evaluator.getTypeOfExpression(node.d.rightExpr);
+        assert.strictEqual(left.props?.inferredTupleLiteral?.alternatives, 8);
+        let calls = 0;
+        evaluator.getTypeOfMagicMethodCall = (...args) => {
+            calls++;
+            return original(...args);
+        };
+        try {
+            const result = evaluator.getTypeOfExpression(node);
+            assert.ok(calls > 0 && calls <= 2, `Builtin scalar ordering expanded ${calls} magic calls`);
+            assert.ok((0, types_1.isTypeSame)(result.type, evaluator.getBuiltInObject(node, 'bool')));
+        }
+        finally {
+            evaluator.getTypeOfMagicMethodCall = original;
+        }
+    }
+});
+test('TupleLiteralInferenceConstantIndexWorkBound', () => {
+    const values = Array.from({ length: 32 }, (_, index) => index % 7).join(', ');
+    const lines = [
+        '// @filename: test.py',
+        '////def index_row() -> None:',
+        `////    nested = ((${values},),)`,
+        '////    row = nested[0]',
+        '////    value = /*row*/row[0]',
+    ];
+    const state = (0, testState_1.parseAndGetTestState)(lines.join('\n')).state;
+    const evaluator = state.program.evaluator;
+    const rowNode = (0, testState_1.getNodeAtMarker)(state, 'row');
+    assert.ok(rowNode.nodeType === 38 /* ParseNodeType.Name */);
+    const node = rowNode.parent;
+    assert.ok(node?.nodeType === 27 /* ParseNodeType.Index */);
+    const row = evaluator.getTypeOfExpression(rowNode).type;
+    assert.ok((0, types_1.isClassInstance)(row) && row.priv.tupleTypeArgs?.length === 32);
+    const intType = evaluator.getBuiltInObject(node, 'int');
+    assert.ok((0, types_1.isClassInstance)(intType));
+    const expectedType = types_1.ClassType.cloneWithLiteral(intType, 0);
+    const literals = new Set();
+    const seen = new Set();
+    const visit = (type) => {
+        if (seen.has(type))
+            return;
+        seen.add(type);
+        if ((0, types_1.isUnion)(type)) {
+            type.priv.subtypes.forEach(visit);
+        }
+        else if ((0, types_1.isClassInstance)(type)) {
+            if (type.priv.literalValue !== undefined)
+                literals.add(type.priv);
+            type.priv.typeArgs?.forEach(visit);
+            type.priv.tupleTypeArgs?.forEach((arg) => visit(arg.type));
+        }
+    };
+    visit(row);
+    assert.ok(literals.size >= 7);
+    let reads = 0;
+    literals.forEach((priv) => {
+        const value = priv.literalValue;
+        Object.defineProperty(priv, 'literalValue', {
+            get: () => {
+                reads++;
+                return value;
+            },
+        });
+    });
+    const result = evaluator.getTypeOfExpression(node);
+    const indexReads = reads;
+    assert.ok((0, types_1.isTypeSame)(result.type, expectedType));
+    assert.ok(indexReads < 8, `Constant tuple indexing reprocessed ${indexReads} literal payloads`);
+});
+test('TupleLiteralInferenceConstantIndexMethodContract', () => {
+    const code = `// @filename: test.py
+////class /*noncallable*/NonCallable:
+////    __getitem__: None
+////class /*constrained*/ConstrainedSelf:
+////    def __getitem__(self: str, index: int) -> str:
+////        return ""
+////def index_row(value: tuple[int, str]) -> None:
+////    result = /*row*/value[0]
+`;
+    for (const mode of ['missing', 'inherited', 'noncallable', 'constrained']) {
+        const state = (0, testState_1.parseAndGetTestState)(code).state;
+        const evaluator = state.program.evaluator;
+        const rowNode = (0, testState_1.getNodeAtMarker)(state, 'row');
+        assert.ok(rowNode.nodeType === 38 /* ParseNodeType.Name */);
+        const node = rowNode.parent;
+        assert.ok(node?.nodeType === 27 /* ParseNodeType.Index */);
+        const row = evaluator.getTypeOfExpression(rowNode).type;
+        assert.ok((0, types_1.isClassInstance)(row));
+        const originalMembers = row.shared.mro.filter(types_1.isInstantiableClass).map((type) => ({
+            fields: type.shared.fields,
+            symbol: type.shared.fields.get('__getitem__'),
+        }));
+        assert.ok(row.shared.fields.has('__getitem__'));
+        try {
+            if (mode === 'missing') {
+                originalMembers.forEach(({ fields }) => fields.delete('__getitem__'));
+            }
+            else if (mode === 'inherited') {
+                row.shared.fields.delete('__getitem__');
+            }
+            else {
+                const classNode = (0, testState_1.getNodeAtMarker)(state, mode);
+                assert.ok(classNode.nodeType === 38 /* ParseNodeType.Name */);
+                const replacement = evaluator.getTypeOfExpression(classNode).type;
+                assert.ok((0, types_1.isInstantiableClass)(replacement));
+                const symbol = replacement.shared.fields.get('__getitem__');
+                assert.ok(symbol);
+                row.shared.fields.set('__getitem__', symbol);
+            }
+            const method = evaluator.getBoundMagicMethod(row, '__getitem__');
+            const result = evaluator.getTypeOfExpression(node).type;
+            if (mode === 'inherited') {
+                assert.ok(method);
+                assert.ok((0, types_1.isTypeSame)(result, evaluator.getBuiltInObject(node, 'int')));
+            }
+            else {
+                assert.ok(!method, `Native tuple method should not bind (${mode})`);
+                assert.ok((0, types_1.isUnknown)(result));
+            }
+        }
+        finally {
+            originalMembers.forEach(({ fields, symbol }) => {
+                if (symbol) {
+                    fields.set('__getitem__', symbol);
+                }
+                else {
+                    fields.delete('__getitem__');
+                }
+            });
+        }
+    }
+});
+test('TupleComparisonResults21', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults21.py']);
+    TestUtils.validateResults(analysisResults, 13);
+    assert.strictEqual(analysisResults[0].errors.filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportArgumentType).length, 11);
+    assert.strictEqual(analysisResults[0].errors.filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportIndexIssue).length, 2);
+});
+test('TupleComparisonResults22', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults22.py']);
+    TestUtils.validateResults(analysisResults, 8);
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => [diag.getRule(), diag.range.start.line + 1]), [
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 29],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 41],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 56],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 63],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 71],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 80],
+        [diagnosticRules_1.DiagnosticRule.reportReturnType, 142],
+        [diagnosticRules_1.DiagnosticRule.reportReturnType, 146],
+    ]);
+});
+test('TupleComparisonFreshEmptyListWorkBound', () => {
+    for (const [width, exact] of [
+        [types_1.maxSubtypesForInferredType, true],
+        [types_1.maxSubtypesForInferredType + 1, true],
+        [types_1.maxSubtypesForInferredType, false],
+        [types_1.maxSubtypesForInferredType + 1, false],
+    ]) {
+        const left = Array.from({ length: width }, () => '[]').join(', ');
+        const right = Array.from({ length: width }, () => (exact ? '[ReturnsText()]' : 'other')).join(', ');
+        const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////class ReturnsText:
+////    def __lt__(self, other: object) -> str: ...
+////def compare(other: list[ReturnsText]) -> None:
+////    (/*empty*/${left}) < (${right})
+`).state;
+        const evaluator = state.program.evaluator;
+        const emptyNode = (0, testState_1.getNodeAtMarker)(state, 'empty');
+        assert.ok(emptyNode.nodeType === 34 /* ParseNodeType.List */);
+        const leftNode = emptyNode.parent;
+        assert.ok(leftNode?.nodeType === 52 /* ParseNodeType.Tuple */);
+        const comparison = leftNode.parent;
+        assert.ok(comparison?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+        const rightNode = comparison.d.rightExpr;
+        assert.ok(rightNode.nodeType === 52 /* ParseNodeType.Tuple */);
+        const leftType = evaluator.getTypeOfExpression(leftNode).type;
+        const rightType = evaluator.getTypeOfExpression(rightNode).type;
+        assert.ok((0, types_1.isClassInstance)(leftType) && (0, types_1.isClassInstance)(rightType));
+        const nodes = [...leftNode.d.items, ...rightNode.d.items];
+        const descriptors = nodes.map((node) => Object.getOwnPropertyDescriptor(node, 'nodeType'));
+        let reads = 0;
+        nodes.forEach((node, index) => {
+            Object.defineProperty(node, 'nodeType', {
+                get: () => {
+                    reads++;
+                    return descriptors[index].value;
+                },
+                configurable: true,
+            });
+        });
+        let result;
+        try {
+            result = TupleComparison.getTupleComparisonResult(evaluator, leftType, rightType, 20 /* OperatorType.LessThan */, comparison);
+        }
+        finally {
+            nodes.forEach((node, index) => Object.defineProperty(node, 'nodeType', descriptors[index]));
+        }
+        assert.ok(result);
+        assert.strictEqual(evaluator.printType(result.type), exact && width === types_1.maxSubtypesForInferredType ? 'bool' : 'Unknown | bool');
+        assert.ok(reads <= 4 * width, `Empty-list proof repeated source scans (${reads} node-kind reads)`);
+    }
+});
+test('TupleComparisonResults23', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleComparisonResults23.py']);
+    TestUtils.validateResults(analysisResults, 9);
+    assert.deepStrictEqual(analysisResults[0].errors.map((diag) => [diag.getRule(), diag.range.start.line + 1]), [
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 35],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 36],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 37],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 38],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 50],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 51],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 52],
+        [diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, 53],
+        [diagnosticRules_1.DiagnosticRule.reportReturnType, 83],
+    ]);
+});
+test('TupleComparisonFreshEmptyListChainedComparison', () => {
+    for (const [operator, token] of [
+        [20 /* OperatorType.LessThan */, '<'],
+        [21 /* OperatorType.LessThanOrEqual */, '<='],
+        [15 /* OperatorType.GreaterThan */, '>'],
+        [16 /* OperatorType.GreaterThanOrEqual */, '>='],
+    ]) {
+        for (const parenthesized of [false, true]) {
+            const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////class ReturnsText:
+////    def __lt__(self, other: object) -> str: ...
+////class MutatesTuple:
+////    def __lt__(self, other: tuple[list[ReturnsText]] | bool) -> bool:
+////        if isinstance(other, tuple):
+////            other[0].append(ReturnsText())
+////        return True
+////def compare(prefix: MutatesTuple) -> None:
+////    prefix < ${parenthesized ? '(' : ''}(/*empty*/[],) ${token} ([ReturnsText()],)${parenthesized ? ')' : ''}
+`).state;
+            const evaluator = state.program.evaluator;
+            const emptyNode = (0, testState_1.getNodeAtMarker)(state, 'empty');
+            assert.ok(emptyNode.nodeType === 34 /* ParseNodeType.List */);
+            const leftNode = emptyNode.parent;
+            assert.ok(leftNode?.nodeType === 52 /* ParseNodeType.Tuple */);
+            const comparison = leftNode.parent;
+            assert.ok(comparison?.nodeType === 7 /* ParseNodeType.BinaryOperation */);
+            assert.strictEqual(!!comparison.d.hasParens, parenthesized);
+            const rightNode = comparison.d.rightExpr;
+            assert.ok(rightNode.nodeType === 52 /* ParseNodeType.Tuple */);
+            const leftType = evaluator.getTypeOfExpression(leftNode).type;
+            const rightType = evaluator.getTypeOfExpression(rightNode).type;
+            assert.ok((0, types_1.isClassInstance)(leftType) && (0, types_1.isClassInstance)(rightType));
+            const result = TupleComparison.getTupleComparisonResult(evaluator, leftType, rightType, operator, comparison);
+            assert.ok(result);
+            assert.strictEqual(evaluator.printType(result.type), parenthesized ? 'bool' : 'Unknown | bool');
+        }
+    }
+});
+test('TupleLiteralInferenceUnionRetentionWorkBound', () => {
+    for (const width of [8, 9]) {
+        const alternatives = Array.from({ length: width }, (_, index) => `tuple[Literal[${index}]]`).join(' | ');
+        const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////from typing import Literal
+////def retain(value: ${alternatives}, fallback: tuple[int]) -> None:
+////    /*value*/value
+////    /*fallback*/fallback
+`).state;
+        const evaluator = state.program.evaluator;
+        const nameNode = (0, testState_1.getNodeAtMarker)(state, 'value');
+        const fallbackNode = (0, testState_1.getNodeAtMarker)(state, 'fallback');
+        assert.ok(nameNode.nodeType === 38 /* ParseNodeType.Name */ && fallbackNode.nodeType === 38 /* ParseNodeType.Name */);
+        const type = (0, types_1.retainInferredTupleLiterals)(evaluator.getTypeOfExpression(nameNode).type, evaluator.getTypeOfExpression(fallbackNode).type);
+        assert.ok((0, types_1.isUnion)(type) && type.priv.subtypes.length === width);
+        const info = type.props?.inferredTupleLiteral;
+        assert.ok(info && info.alternatives === width);
+        const tuples = type.priv.subtypes.filter(types_1.isClassInstance);
+        assert.strictEqual(tuples.length, width);
+        const values = tuples.map((tuple) => {
+            const args = tuple.priv.tupleTypeArgs;
+            assert.ok(args?.length === 1);
+            const value = args[0].type;
+            assert.ok((0, types_1.isClassInstance)(value) && typeof value.priv.literalValue === 'number');
+            return value.priv.literalValue;
+        });
+        assert.deepStrictEqual(values.sort((left, right) => left - right), Array.from({ length: width }, (_, index) => index));
+        let reads = 0;
+        tuples.forEach((tuple) => {
+            const args = tuple.priv.tupleTypeArgs;
+            Object.defineProperty(tuple.priv, 'tupleTypeArgs', {
+                get: () => {
+                    reads++;
+                    return args;
+                },
+            });
+        });
+        const retained = (0, types_1.retainInferredTupleLiterals)(type, info.baseType);
+        const retentionReads = reads;
+        assert.ok(retentionReads > 0 && retentionReads <= types_1.maxSubtypesForInferredType, `Unchanged ${width}-way tuple union required ${retentionReads} tuple-argument reads`);
+        assert.ok((0, types_1.isUnion)(retained) && retained.priv.subtypes === type.priv.subtypes);
+        assert.ok(retained.props?.inferredTupleLiteral?.baseType === info.baseType);
+        assert.strictEqual(retained.props?.inferredTupleLiteral?.alternatives, width);
+        assert.strictEqual(evaluator.printType(retained), evaluator.printType(type));
+    }
+});
+test('TupleLiteralInferenceRetentionSubtypeNormalization', () => {
+    const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////from typing import Literal
+////def retain(value: Literal[0] | tuple[Literal[1]], fallback: int | tuple[int]) -> None:
+////    /*value*/value
+////    /*fallback*/fallback
+`).state;
+    const evaluator = state.program.evaluator;
+    const valueNode = (0, testState_1.getNodeAtMarker)(state, 'value');
+    const fallbackNode = (0, testState_1.getNodeAtMarker)(state, 'fallback');
+    assert.ok(valueNode.nodeType === 38 /* ParseNodeType.Name */ && fallbackNode.nodeType === 38 /* ParseNodeType.Name */);
+    const type = evaluator.getTypeOfExpression(valueNode).type;
+    const baseType = evaluator.getTypeOfExpression(fallbackNode).type;
+    assert.ok((0, types_1.isUnion)(type) && type.priv.subtypes.length === 2);
+    const literal = type.priv.subtypes.find((subtype) => (0, types_1.isClassInstance)(subtype) && subtype.priv.literalValue === 0);
+    const tuple = type.priv.subtypes.find((subtype) => (0, types_1.isClassInstance)(subtype) && !!subtype.priv.tupleTypeArgs);
+    assert.ok(literal && tuple && !literal.props?.inferredTupleLiteral);
+    const retained = (0, types_1.retainInferredTupleLiterals)(type, baseType);
+    assert.ok((0, types_1.isUnion)(retained) && retained.priv.subtypes.length === 2);
+    const retainedLiteral = retained.priv.subtypes.find((subtype) => (0, types_1.isClassInstance)(subtype) && subtype.priv.literalValue === 0);
+    assert.ok(retainedLiteral && retainedLiteral !== literal);
+    assert.ok(retainedLiteral.props?.inferredTupleLiteral);
+    assert.ok((0, types_1.isClassInstance)(retainedLiteral.props.inferredTupleLiteral.baseType));
+    assert.strictEqual(retainedLiteral.props.inferredTupleLiteral.baseType.priv.literalValue, undefined);
+    assert.ok(retained.priv.subtypes.includes(tuple));
+    assert.ok(retained.props?.inferredTupleLiteral?.baseType === baseType);
+    assert.strictEqual(literal.props?.inferredTupleLiteral, undefined);
+    assert.strictEqual(evaluator.printType(retained), evaluator.printType(type));
+});
+test('TupleLiteralInferenceUnchangedSpecializationWorkBound', () => {
+    for (const width of [8, 9]) {
+        const choices = Array.from({ length: width }, (_, index) => `(${index},)`).join(', ');
+        const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////def select() -> None:
+////    choices = (${choices})
+////    /*choices*/choices
+`).state;
+        const evaluator = state.program.evaluator;
+        const node = (0, testState_1.getNodeAtMarker)(state, 'choices');
+        assert.ok(node.nodeType === 38 /* ParseNodeType.Name */);
+        const type = evaluator.getTypeOfExpression(node).type;
+        assert.ok((0, types_1.isClassInstance)(type) && types_1.ClassType.isTupleClass(type));
+        const originalArgs = type.priv.tupleTypeArgs;
+        assert.ok(originalArgs && originalArgs.length === width);
+        const info = type.props?.inferredTupleLiteral;
+        assert.ok(info && info.alternatives === 1);
+        let reads = 0;
+        originalArgs.forEach((arg, index) => {
+            const tuple = arg.type;
+            assert.ok((0, types_1.isClassInstance)(tuple));
+            const args = tuple.priv.tupleTypeArgs;
+            assert.ok(args?.length === 1);
+            const value = args[0].type;
+            assert.ok((0, types_1.isClassInstance)(value) && value.priv.literalValue === index);
+            Object.defineProperty(tuple.priv, 'tupleTypeArgs', {
+                get: () => {
+                    reads++;
+                    return args;
+                },
+            });
+        });
+        const transformedArgs = [];
+        let readsAtLastTransform = 0;
+        class IdentityTransformer extends typeUtils_1.TypeVarTransformer {
+            apply(arg) {
+                transformedArgs.push(arg);
+                readsAtLastTransform = reads;
+                return arg;
+            }
+        }
+        const transformed = new IdentityTransformer().transformTypeVarsInClassType(type, 0);
+        const recombinationReads = reads - readsAtLastTransform;
+        assert.strictEqual(transformedArgs.length, width);
+        originalArgs.forEach((arg, index) => assert.strictEqual(transformedArgs[index], arg.type));
+        assert.strictEqual(recombinationReads, 0, `Unchanged ${width}-element tuple required ${recombinationReads} tuple-argument reads after transformation`);
+        assert.strictEqual(transformed, type);
+        assert.strictEqual(type.priv.tupleTypeArgs, originalArgs);
+        assert.strictEqual(type.props?.inferredTupleLiteral, info);
+    }
+});
+test('TupleLiteralInferenceUnmarkedSpecializationWorkBound', () => {
+    for (const width of [types_1.maxSubtypesForInferredType, 8, 16, 32]) {
+        const entries = Array.from({ length: width }, () => 'int').join(', ');
+        const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////def specialize(value: tuple[${entries}]) -> None:
+////    /*value*/value
+`).state;
+        const evaluator = state.program.evaluator;
+        const node = (0, testState_1.getNodeAtMarker)(state, 'value');
+        assert.ok(node.nodeType === 38 /* ParseNodeType.Name */);
+        const type = evaluator.getTypeOfExpression(node).type;
+        assert.ok((0, types_1.isClassInstance)(type) && types_1.ClassType.isTupleClass(type));
+        assert.strictEqual(type.props?.inferredTupleLiteral, undefined);
+        const args = type.priv.tupleTypeArgs;
+        assert.ok(args?.length === width);
+        const expectedType = evaluator.printType(type);
+        const descriptors = args.map((arg) => Object.getOwnPropertyDescriptor(arg, 'type'));
+        let reads = 0;
+        args.forEach((arg, index) => {
+            const value = arg.type;
+            assert.strictEqual(value.props?.inferredTupleLiteral, undefined);
+            Object.defineProperty(arg, 'type', {
+                configurable: true,
+                get: () => {
+                    reads++;
+                    return value;
+                },
+            });
+            assert.ok(descriptors[index]);
+        });
+        let specialized;
+        try {
+            specialized = types_1.ClassType.specialize(type, type.priv.typeArgs, type.priv.isTypeArgExplicit, !!type.priv.includeSubclasses, args, type.priv.isEmptyContainer);
+        }
+        finally {
+            args.forEach((arg, index) => Object.defineProperty(arg, 'type', descriptors[index]));
+        }
+        assert.ok(reads <= width, `Unmarked ${width}-element specialization required ${reads} tuple-entry reads`);
+        assert.notStrictEqual(specialized, type);
+        assert.notStrictEqual(specialized.priv.tupleTypeArgs, args);
+        assert.deepStrictEqual(specialized.priv.tupleTypeArgs, args);
+        assert.strictEqual(specialized.priv.typeArgs, type.priv.typeArgs);
+        assert.strictEqual(specialized.props?.inferredTupleLiteral, undefined);
+        assert.strictEqual(evaluator.printType(specialized), expectedType);
+        assert.strictEqual(type.priv.tupleTypeArgs, args);
+    }
+});
+test('TupleLiteralInferenceSingletonUnionWorkBound', () => {
+    const state = (0, testState_1.parseAndGetTestState)('// @filename: test.py\n//// /*value*/0').state;
+    const evaluator = state.program.evaluator;
+    const node = (0, testState_1.getNodeAtMarker)(state, 'value');
+    const intType = evaluator.getBuiltInObject(node, 'int');
+    const strType = evaluator.getBuiltInObject(node, 'str');
+    assert.ok((0, types_1.isClassInstance)(intType));
+    const retained = (0, types_1.retainInferredTupleLiterals)(types_1.ClassType.cloneWithLiteral(intType, 1), intType);
+    assert.ok(retained.props?.inferredTupleLiteral);
+    for (const original of [
+        intType,
+        (0, types_1.combineTypes)([intType, strType]),
+        retained,
+        types_1.NeverType.createNever(),
+        types_1.UnknownType.create(),
+    ]) {
+        const type = types_1.TypeBase.cloneType(original);
+        const props = type.props;
+        const descriptor = Object.getOwnPropertyDescriptor(type, 'props');
+        let reads = 0;
+        Object.defineProperty(type, 'props', {
+            configurable: true,
+            get: () => {
+                reads++;
+                return props;
+            },
+        });
+        try {
+            assert.strictEqual((0, types_1.combineTypes)([type]), type);
+            assert.strictEqual((0, types_1.combineTypes)([type], { skipElideRedundantLiterals: true }), type);
+            assert.strictEqual((0, types_1.combineTypes)([type], { maxSubtypeCount: 0 }), type);
+        }
+        finally {
+            if (descriptor) {
+                Object.defineProperty(type, 'props', descriptor);
+            }
+            else {
+                delete type.props;
+            }
+        }
+        assert.strictEqual(reads, 0, 'A singleton union should not inspect optional inference metadata');
+        assert.strictEqual(type.props, props);
+    }
+});
+test('TupleSpecializationTypeVarSubstitution', () => {
+    const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////from typing import TypeVar, TypeVarTuple, Unpack
+////T = TypeVar("T")
+////Ts = TypeVarTuple("Ts")
+////def /*function*/specialize(
+////    bounded: tuple[T, int],
+////    unbounded: tuple[T, ...],
+////    unpacked: tuple[Unpack[Ts]],
+////    scalar: str,
+////    pair: tuple[str, int],
+////) -> None:
+////    /*boundBody*/bounded
+`).state;
+    const evaluator = state.program.evaluator;
+    const functionNode = (0, testState_1.getNodeAtMarker)(state, 'function').parent;
+    assert.ok(functionNode?.nodeType === 31 /* ParseNodeType.Function */);
+    const functionResult = evaluator.getTypeOfFunction(functionNode);
+    assert.ok(functionResult);
+    const typeAt = (index) => {
+        const type = types_1.FunctionType.getParamType(functionResult.functionType, index);
+        assert.ok((0, types_1.isClassInstance)(type) && types_1.ClassType.isTupleClass(type));
+        return type;
+    };
+    const scalar = types_1.FunctionType.getParamType(functionResult.functionType, 3);
+    assert.ok((0, types_1.isClassInstance)(scalar) && types_1.ClassType.isBuiltIn(scalar, 'str'));
+    for (const index of [0, 1]) {
+        const type = typeAt(index);
+        const args = type.priv.tupleTypeArgs;
+        assert.ok(args && (0, types_1.isTypeVar)(args[0].type) && !types_1.TypeVarType.isBound(args[0].type));
+        const originalTypeVar = args[0].type;
+        const solution = new constraintSolution_1.ConstraintSolution();
+        solution.setType(originalTypeVar, scalar);
+        const specialized = (0, typeUtils_1.applySolvedTypeVars)(type, solution);
+        assert.ok((0, types_1.isClassInstance)(specialized) && specialized !== type);
+        assert.strictEqual(evaluator.printType(specialized), index === 0 ? 'tuple[str, int]' : 'tuple[str, ...]');
+        const effectiveArgs = specialized.priv.typeArgs;
+        assert.ok(effectiveArgs?.length === 1);
+        assert.strictEqual(evaluator.printType(effectiveArgs[0]), index === 0 ? 'str | int' : 'str');
+        assert.strictEqual(type.priv.tupleTypeArgs, args);
+        assert.strictEqual(args[0].type, originalTypeVar);
+        if (index === 0) {
+            const boundNode = (0, testState_1.getNodeAtMarker)(state, 'boundBody');
+            assert.ok(boundNode.nodeType === 38 /* ParseNodeType.Name */);
+            const boundType = evaluator.getTypeOfExpression(boundNode).type;
+            assert.ok((0, types_1.isClassInstance)(boundType) && boundType.priv.tupleTypeArgs);
+            const boundTypeVar = boundType.priv.tupleTypeArgs[0].type;
+            assert.ok((0, types_1.isTypeVar)(boundTypeVar) && types_1.TypeVarType.isBound(boundTypeVar));
+            assert.strictEqual((0, typeUtils_1.applySolvedTypeVars)(boundType, solution), boundType);
+        }
+        else {
+            solution.setType(originalTypeVar, types_1.NeverType.createNever());
+            const empty = (0, typeUtils_1.applySolvedTypeVars)(type, solution);
+            assert.ok((0, types_1.isClassInstance)(empty) && empty.priv.tupleTypeArgs?.length === 0);
+            assert.strictEqual(evaluator.printType(empty), 'tuple[()]');
+            assert.ok(empty.priv.typeArgs?.length === 1 && (0, types_1.isNever)(empty.priv.typeArgs[0]));
+        }
+    }
+    const unpacked = typeAt(2);
+    const args = unpacked.priv.tupleTypeArgs;
+    assert.ok(args?.length === 1 && (0, types_1.isTypeVarTuple)(args[0].type));
+    const solution = new constraintSolution_1.ConstraintSolution();
+    solution.setType(args[0].type, types_1.ClassType.cloneForUnpacked(typeAt(4)));
+    const specialized = (0, typeUtils_1.applySolvedTypeVars)(unpacked, solution);
+    assert.ok((0, types_1.isClassInstance)(specialized) && specialized !== unpacked);
+    assert.strictEqual(evaluator.printType(specialized), 'tuple[str, int]');
+    const effectiveArgs = specialized.priv.typeArgs;
+    assert.ok(effectiveArgs?.length === 1);
+    assert.strictEqual(evaluator.printType(effectiveArgs[0]), 'str | int');
+    assert.strictEqual(unpacked.priv.tupleTypeArgs, args);
+    assert.ok((0, types_1.isTypeVarTuple)(args[0].type));
+});
+test('TupleLiteralInference7', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tupleLiteralInference7.py']);
+    TestUtils.validateResults(analysisResults, 7);
+    assert.deepStrictEqual(analysisResults[0].errors
+        .filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportArgumentType)
+        .map((diag) => diag.range.start.line + 1), [24, 29, 51, 61, 75, 90]);
+    assert.deepStrictEqual(analysisResults[0].errors
+        .filter((diag) => diag.getRule() === diagnosticRules_1.DiagnosticRule.reportCallIssue)
+        .map((diag) => diag.range.start.line + 1), [90]);
+});
+test('TupleLiteralInferenceDynamicIndexWorkBound', () => {
+    for (const width of [8, 9, 2]) {
+        const choices = Array.from({ length: width }, (_, index) => `(${index},)`).join(', ');
+        const state = (0, testState_1.parseAndGetTestState)(`// @filename: test.py
+////def select(index: int) -> None:
+////    choices = (${choices})
+////    selected = /*selected*/choices[index]
+`).state;
+        const evaluator = state.program.evaluator;
+        const nameNode = (0, testState_1.getNodeAtMarker)(state, 'selected');
+        assert.ok(nameNode.nodeType === 38 /* ParseNodeType.Name */);
+        const node = nameNode.parent;
+        assert.ok(node?.nodeType === 27 /* ParseNodeType.Index */);
+        const type = evaluator.getTypeOfExpression(nameNode).type;
+        assert.ok((0, types_1.isClassInstance)(type) && type.priv.tupleTypeArgs?.length === width);
+        const originalArgs = type.priv.tupleTypeArgs;
+        const info = type.props?.inferredTupleLiteral;
+        assert.ok(info && (0, types_1.isClassInstance)(info.baseType));
+        const intType = evaluator.getBuiltInObject(node, 'int');
+        let reads = 0;
+        originalArgs.forEach((arg, index) => {
+            const row = arg.type;
+            assert.ok((0, types_1.isClassInstance)(row));
+            const args = row.priv.tupleTypeArgs;
+            assert.ok(args?.length === 1);
+            const value = args[0].type;
+            assert.ok((0, types_1.isClassInstance)(value) && value.priv.literalValue === index);
+            Object.defineProperty(row.priv, 'tupleTypeArgs', {
+                get: () => {
+                    reads++;
+                    return args;
+                },
+            });
+        });
+        const result = evaluator.getTypeOfExpression(node);
+        const indexReads = reads;
+        assert.ok(indexReads <= types_1.maxSubtypesForInferredType, `Dynamic ${width}-row indexing reprocessed ${indexReads} retained tuple arguments`);
+        assert.ok((0, types_1.isClassInstance)(result.type) && result.type.priv.tupleTypeArgs?.length === 1);
+        assert.ok((0, types_1.isTypeSame)(result.type.priv.tupleTypeArgs[0].type, intType));
+        assert.strictEqual(result.type.props?.inferredTupleLiteral, undefined);
+        assert.strictEqual(type.priv.tupleTypeArgs, originalArgs);
+        assert.strictEqual(type.props?.inferredTupleLiteral, info);
+    }
+});
 //# sourceMappingURL=typeEvaluator8.test.js.map