Fix missing type changes for equal-comparing list items (#605)

[Sanjays2402]

Fixes #605

The bug

DeepDiff([2], [2.0]) reports no difference at all, even though the scalar and dict equivalents both correctly report an int → float type change:

>>> from deepdiff import DeepDiff
>>> DeepDiff(2, 2.0)
{'type_changes': {'root': {'old_type': int, 'new_type': float, 'old_value': 2, 'new_value': 2.0}}}
>>> DeepDiff({'a': 2}, {'a': 2.0})
{'type_changes': {"root['a']": {'old_type': int, 'new_type': float, ...}}}
>>> DeepDiff([2], [2.0])      # ← inconsistent
{}

The same silent miss affects any equal-but-differently-typed pair inside a list, and changes buried among unchanged items:

>>> DeepDiff([1, 2, 3], [1, 2.0, 3])   # {}  (expected type_change at root[1])
>>> DeepDiff([1], [Decimal(1)])        # {}
>>> DeepDiff([True], [1])              # {}

Root cause

For ordered iterables whose items are all basic-hashable, _diff_iterable_in_order diffs the two sequences with difflib.SequenceMatcher. Because 2 == 2.0 (and hash(2) == hash(2.0)), SequenceMatcher classifies the pair as an 'equal' opcode:

>>> import difflib
>>> difflib.SequenceMatcher(None, [2], [2.0], autojunk=False).get_opcodes()
[('equal', 0, 1, 0, 1)]

The 'equal' branch in _diff_ordered_iterable_by_difflib recorded the opcode and continued — the items were never handed to _diff(), which is the only place the type-change check get_type(t1) != get_type(t2) lives. So the difference vanished. Scalars and dict values go through _diff() directly, which is why they behave correctly.

This is the ordered-diff complement of the ignore_order=True int-vs-float fix already noted in the v9.0.0 changelog.

The fix

In the 'equal' opcode branch, recurse into _diff() for any aligned pair whose types differ:

if tag == 'equal':
    opcodes_with_values.append(Opcode(...))
    for index in range(t1_to_index - t1_from_index):
        x = level.t1[t1_from_index + index]
        y = level.t2[t2_from_index + index]
        if get_type(x) != get_type(y):
            change_level = level.branch_deeper(x, y, ...)
            self._diff(change_level, parents_ids, local_tree=local_tree)
    continue

Routing through _diff() reuses the existing type-change machinery, so every option is honored automatically — no duplicated logic.

Before / after

Input	Before	After
DeepDiff([2], [2.0])	{}	type_changes root[0]: int→float
DeepDiff([1,2,3], [1,2.0,3])	{}	type_changes root[1]: int→float
DeepDiff([1], [Decimal(1)])	{}	type_changes root[0]: int→Decimal
DeepDiff([2], [2.0], ignore_numeric_type_changes=True)	{}	{} (unchanged — correctly suppressed)
DeepDiff([2], [2])	{}	{} (unchanged — no over-reporting)

Tests

Added three regression tests in tests/test_diff_text.py (repo style):

• test_item_type_change_in_list — [2] vs [2.0] reports the change and asserts it matches the scalar result
• test_item_type_change_in_list_among_unchanged_items — [1,2,3] vs [1,2.0,3]
• test_item_type_change_in_list_ignored_when_requested — ignore_numeric_type_changes=True still yields {}

Proof they guard the bug: with the source change stashed, the two positive tests FAIL; restored, all three PASS.

Full suite unchanged from baseline: 1251 passed, 44 skipped (the only failures locally are missing-optional-dep / macOS setrlimit env artifacts, identical with and without this change).