Optimize breaking_changes_checker performance for large packages

[Copilot]

for #45952

The changelog generator is prohibitively slow on large packages like azure-mgmt-network due to redundant file I/O/AST parsing, quadratic algorithms in post-processing, and unnecessary deep copies.

AST caching and early exit

• Module-level AST cache (_ast_cache/_get_parsed_module): get_properties() and get_overloads() both parse the same source files per class per base class. Now parsed once, cached by path, shared across both call sites.
• Exception-based early exit in ClassTreeAnalyzer: raises _ClassNodeFound to break out of the full ast.NodeVisitor traversal immediately upon finding the target class, rather than continuing to walk the entire tree.

Algorithm fixes

• run_async_cleanup(): O(n²m) → O(n). Replaced nested loop + list.remove() with a set of non-aio change keys and a single-pass list comprehension. Handles unhashable types (lists in parameter ordering tuples) via recursive _make_hashable().

# Before: O(n * m * m) — nested scan + linear removal
for change in non_aio_changes:
    for c in changes_list:
        if "aio" in c[2] and change[1] == c[1] and change[3:] == c[3:]:
            changes_list.remove(c)  # O(n)

# After: O(n) — set lookup + filter
non_aio_keys = {_make_key(bc) for bc in changes_list if "aio" not in bc[2]}
changes_list[:] = [bc for bc in changes_list if "aio" not in bc[2] or _make_key(bc) not in non_aio_keys]

• get_reportable_changes(): eliminated deepcopy + list.remove(). Single-pass filter builds a new list directly. Suppression objects pre-created once instead of per-change. re.findall() → re.search().

Performance tests

14 new tests in test_performance.py covering correctness and benchmarks:

• 50K-change async cleanup completes in <2s
• 5K changes with 100 ignore rules filtered in <1s
• Full ChangelogTracker run on large synthetic API surface in <5s
• AST cache hit verification and 200-lookup benchmark
• Early exit speedup measurement (first-class vs last-class in 500-class file)

[Copilot]

Pull request overview

Improves breaking_changes_checker runtime on large Azure SDK packages by reducing redundant AST parsing and optimizing post-processing algorithms that previously had quadratic behavior.

Changes:

• Added AST parsing cache and an early-exit mechanism for locating class nodes during AST traversal.
• Optimized run_async_cleanup() and get_reportable_changes() to avoid list.remove()/deepcopy-driven quadratic patterns.
• Added a new test_performance.py test module covering correctness and performance/benchmark scenarios.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 5 comments.

File	Description
scripts/breaking_changes_checker/detect_breaking_changes.py	Adds _ast_cache + cached parsing helpers and exception-based early exit in ClassTreeAnalyzer; clears cache at start of report generation.
scripts/breaking_changes_checker/breaking_changes_tracker.py	Reworks async cleanup and ignore-rule filtering to single-pass/set-based implementations.
scripts/breaking_changes_checker/tests/test_performance.py	Introduces new performance-focused tests/benchmarks and cache/early-exit verification.

[catalinaperalta]

I think overall these look like good improvements to the tool, thanks for working on this! My main concern is that there are some things that are changing the behavior and while they seem correct, I wonder if things will begin breaking due to these changes. To build confidence, have you done a run through of the changelog generation for more mgmt plane libraries to check how it behaves in different scenarios?

[catalinaperalta]

I recall there were issues without the deepcopy at some point. How many real packages have you tested this code with?

[catalinaperalta]

Nit: this command was helpful to understand what we're doing