False Positive Error in Type Check Tracker

[ThakeeNathees]

[ThakeeNathees]

to generate diff,
run this from the featre branch, it will generate jac check resutls on feature branch and then checkout to main and does the same and then goes back to feature branch and does the diff calculations and generate the report.

#!/usr/bin/env python3
"""
Script to generate a diff report comparing type checker errors between two branches.
Runs 'jac check' on both the current branch and main branch, then compares the results.

Usage:
    python generate_error_diff_report.py [--current-branch BRANCH] [--main-branch BRANCH]
    
    Defaults:
    - Current branch: detected from git
    - Main branch: main
"""

import re
import subprocess
import sys
import argparse
import shutil
from collections import Counter
from pathlib import Path
from typing import Dict, Set, Tuple

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from matplotlib.gridspec import GridSpec


def normalize_message(message: str) -> str:
    """Normalize an error message by replacing variable parts with placeholders."""
    
    # Replace jaclang type objects: <jaclang.compiler.type_system.types.XYZ object at 0x...>
    message = re.sub(
        r"<jaclang\.compiler\.type_system\.types\.\w+ object at 0x[0-9a-fA-F]+>",
        "<TYPE_OBJ>",
        message
    )
    
    # Replace <class XYZ> patterns
    message = re.sub(r"<class \w+>", "<TYPE>", message)
    
    # Replace quoted parameter/variable names like 'name', 'x', 'args'
    message = re.sub(r"'[a-zA-Z_][a-zA-Z0-9_]*'", "'PARAM'", message)
    
    # Replace quoted string tokens like '"Circle"', '"Unknown"'
    message = re.sub(r'"[^"]*"', '"TOKEN"', message)
    
    # Replace file paths in error checking messages
    message = re.sub(
        r"Could not read file [^:]+:",
        "Could not read file <FILE>:",
        message
    )
    
    # Normalize directory error paths
    message = re.sub(
        r"\[Errno 21\] Is a directory: '[^']*'",
        "[Errno 21] Is a directory: '<DIR>'",
        message
    )
    
    return message.strip()


def should_ignore(line: str, message: str) -> bool:
    """Check if a line/message should be ignored."""
    
    # Ignore "Module not found" warnings
    if message == "Module not found":
        return True
    
    # Ignore "Unexpected token" errors
    if message.startswith("Unexpected token"):
        return True
    
    # Ignore byllm plugin patch messages
    if "Please install a byllm plugin, but for now patching byllm.lib with NonGPT" in line:
        return True
    
    return False


def extract_message(line: str) -> tuple[str, str] | None:
    """
    Extract the error/warning type and message from a line.
    Returns (level, message) or None if not a valid error/warning line.
    """
    
    # Pattern 1: Error: <file>, line X, col Y: <message>
    # Pattern 2: Warning: <file>, line X, col Y: <message>
    match = re.match(r"^(Error|Warning): .+, line \d+, col \d+: (.+)$", line)
    if match:
        return match.group(1), match.group(2)
    
    # Pattern 3: Error checking '<file>': <message>
    match = re.match(r"^Error checking '[^']+': (.+)$", line)
    if match:
        return "Error checking", match.group(1)
    
    return None


def process_error_file(filepath: str) -> Dict[str, Counter]:
    """Process the error file and return counts of unique error types."""
    
    results: Dict[str, Counter] = {
        "Error": Counter(),
        "Warning": Counter(),
        "Error checking": Counter(),
    }
    
    if not Path(filepath).exists():
        return results
    
    with open(filepath, "r") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            
            # Skip byllm plugin patch messages
            if "Please install a byllm plugin" in line:
                continue
            
            extracted = extract_message(line)
            if extracted:
                level, message = extracted
                
                # Skip ignored messages
                if should_ignore(line, message):
                    continue
                
                normalized = normalize_message(message)
                results[level][normalized] += 1
    
    return results


def get_error_set(results: Dict[str, Counter]) -> Set[Tuple[str, str]]:
    """Convert results to a set of (level, normalized_message) tuples."""
    error_set = set()
    for level in ["Error", "Warning", "Error checking"]:
        for msg in results[level]:
            error_set.add((level, msg))
    return error_set


def get_error_counts(results: Dict[str, Counter]) -> Dict[str, int]:
    """Get total counts per category."""
    return {
        "Error": sum(results["Error"].values()),
        "Warning": sum(results["Warning"].values()),
        "Error checking": sum(results["Error checking"].values()),
        "Total": sum(results["Error"].values()) + 
                sum(results["Warning"].values()) + 
                sum(results["Error checking"].values())
    }


def delete_jaccache_folders(root_path: str = ".") -> int:
    """Delete all .jaccache folders recursively. Returns count of deleted folders."""
    root = Path(root_path)
    deleted_count = 0
    
    for jaccache_dir in root.rglob(".jaccache"):
        if jaccache_dir.is_dir():
            try:
                shutil.rmtree(jaccache_dir)
                deleted_count += 1
                print(f"  Deleted: {jaccache_dir}")
            except Exception as e:
                print(f"  Warning: Could not delete {jaccache_dir}: {e}")
    
    return deleted_count


def count_lines(filepath: str) -> int:
    """Count total lines in a file."""
    if not Path(filepath).exists():
        return 0
    try:
        with open(filepath, "r") as f:
            return sum(1 for _ in f)
    except Exception:
        return 0


def create_error_pie_chart(
    results: Dict[str, Counter],
    ax,
    title: str,
    colors: list
) -> None:
    """Create a pie chart for error distribution similar to filter_unique_errors.py."""
    # Combine all errors for the main pie chart
    all_errors = results["Error"] + results["Error checking"]
    total_errors = sum(all_errors.values())
    
    if total_errors == 0:
        ax.text(0.5, 0.5, 'No errors', transform=ax.transAxes,
                ha='center', va='center', fontsize=12, style='italic')
        ax.set_title(title, fontsize=11, fontweight='bold')
        return
    
    # Sort by count and get top errors
    sorted_errors = sorted(all_errors.items(), key=lambda x: -x[1])
    
    # Group smaller errors into "Other" category for cleaner pie chart
    top_n = 10
    top_errors = sorted_errors[:top_n]
    other_count = sum(count for _, count in sorted_errors[top_n:])
    
    if other_count > 0:
        top_errors.append(("Other errors", other_count))
    
    # Prepare data for pie chart
    labels = []
    sizes = []
    for msg, count in top_errors:
        # Truncate long labels
        label = msg[:30] + "..." if len(msg) > 30 else msg
        labels.append(f"{label}\n({count})")
        sizes.append(count)
    
    # Use provided colors or default palette
    if len(colors) < len(sizes):
        default_colors = [
            '#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6',
            '#1abc9c', '#e67e22', '#34495e', '#16a085', '#c0392b',
            '#7f8c8d'
        ]
        colors = default_colors[:len(sizes)]
    
    wedges, texts, autotexts = ax.pie(
        sizes,
        colors=colors[:len(sizes)],
        autopct=lambda p: f'{p:.1f}%' if p > 3 else '',
        startangle=90,
        pctdistance=0.75,
        explode=[0.02] * len(sizes)
    )
    
    # Style the percentage text
    for autotext in autotexts:
        autotext.set_fontsize(8)
        autotext.set_fontweight('bold')
        autotext.set_color('white')
    
    ax.set_title(f'{title}\nTotal: {total_errors:,} errors', 
                 fontsize=11, fontweight='bold', pad=15)


def run_jac_check(output_file: str) -> bool:
    """Run jac check command and save output to file."""
    print(f"  Running: jac check . 2>&1 | tee {output_file}")
    
    # Ensure build directory exists
    Path(output_file).parent.mkdir(parents=True, exist_ok=True)
    
    try:
        # Run jac check and capture output (stderr redirected to stdout)
        result = subprocess.run(
            ["jac", "check", "."],
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True
        )
        
        # Write to output file
        with open(output_file, "w") as f:
            if result.stdout:
                f.write(result.stdout)
        
        return result.returncode == 0
    except Exception as e:
        print(f"  Error running jac check: {e}")
        return False


def compare_errors(
    current_results: Dict[str, Counter],
    main_results: Dict[str, Counter]
) -> Dict[str, any]:
    """Compare two error result sets and return diff information."""
    
    current_set = get_error_set(current_results)
    main_set = get_error_set(main_results)
    
    # Errors fixed: in main but not in current
    fixed_errors = main_set - current_set
    
    # New errors: in current but not in main
    new_errors = current_set - main_set
    
    # Remaining errors: in both
    remaining_errors = current_set & main_set
    
    # Get counts for each category
    current_counts = get_error_counts(current_results)
    main_counts = get_error_counts(main_results)
    
    # Calculate detailed counts for fixed/new errors
    fixed_details = {}
    for level, msg in fixed_errors:
        count_main = main_results[level].get(msg, 0)
        count_current = current_results[level].get(msg, 0)
        fixed_details[(level, msg)] = {
            "main_count": count_main,
            "current_count": count_current,
            "diff": count_main - count_current
        }
    
    new_details = {}
    for level, msg in new_errors:
        count_main = main_results[level].get(msg, 0)
        count_current = current_results[level].get(msg, 0)
        new_details[(level, msg)] = {
            "main_count": count_main,
            "current_count": count_current,
            "diff": count_current - count_main
        }
    
    # Calculate detailed counts for remaining errors (errors in both branches)
    remaining_details = {}
    for level, msg in remaining_errors:
        count_main = main_results[level].get(msg, 0)
        count_current = current_results[level].get(msg, 0)
        diff = count_current - count_main
        remaining_details[(level, msg)] = {
            "main_count": count_main,
            "current_count": count_current,
            "diff": diff
        }
    
    return {
        "fixed_errors": fixed_errors,
        "new_errors": new_errors,
        "remaining_errors": remaining_errors,
        "current_counts": current_counts,
        "main_counts": main_counts,
        "fixed_details": fixed_details,
        "new_details": new_details,
        "remaining_details": remaining_details,
    }


def generate_diff_report(
    diff_data: Dict[str, any],
    current_branch: str,
    main_branch: str,
    current_results: Dict[str, Counter],
    main_results: Dict[str, Counter],
    current_lines: int,
    main_lines: int,
    output_path: str = "build/error_diff_report.png"
) -> None:
    """Generate a visual diff report."""
    
    fixed_errors = diff_data["fixed_errors"]
    new_errors = diff_data["new_errors"]
    remaining_errors = diff_data["remaining_errors"]
    current_counts = diff_data["current_counts"]
    main_counts = diff_data["main_counts"]
    
    # Calculate summary statistics
    total_fixed = len(fixed_errors)
    total_new = len(new_errors)
    total_remaining = len(remaining_errors)
    
    # Calculate count differences
    errors_fixed_count = main_counts["Total"] - current_counts["Total"]
    errors_new_count = current_counts["Total"] - main_counts["Total"]
    
    # Color palette for pie charts
    colors = [
        '#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6',
        '#1abc9c', '#e67e22', '#34495e', '#16a085', '#c0392b',
        '#7f8c8d'
    ]
    
    # Create figure with 2x2 grid layout (larger for bigger pie charts)
    fig = plt.figure(figsize=(22, 12))
    fig.suptitle(
        f'Type Checker Error Diff Report\n{current_branch} vs {main_branch}',
        fontsize=18,
        fontweight='bold',
        y=0.98
    )
    
    # Use GridSpec for clean 2x2 layout
    # Make bottom row taller to accommodate larger pie charts
    gs = GridSpec(2, 2, width_ratios=[1, 1], height_ratios=[0.9, 1.1],
                  hspace=0.3, wspace=0.3)
    
    # Top left: Summary statistics
    ax_summary = fig.add_subplot(gs[0, 0])
    ax_summary.axis('off')
    
    summary_text = f"""
    ════════════════════════════════════════════════════════════════════════════════
    SUMMARY STATISTICS
    ════════════════════════════════════════════════════════════════════════════════
    
    Branch: {current_branch:50s} Main: {main_branch}
    
    Output File Lines:
      • {main_branch:20s} {main_lines:>6,} lines
      • {current_branch:20s} {current_lines:>6,} lines
      • Net Change:            {current_lines - main_lines:>+6,} lines
    
    Total Errors:
      • {main_branch:20s} {main_counts['Total']:>6,} errors
      • {current_branch:20s} {current_counts['Total']:>6,} errors
      • Net Change:            {current_counts['Total'] - main_counts['Total']:>+6,} errors
    
    Error Categories:
      • Errors Fixed:          {total_fixed:>6,} unique types ({errors_fixed_count:>+6,} total instances)
      • New Errors:            {total_new:>6,} unique types ({errors_new_count:>+6,} total instances)
      • Remaining Errors:      {total_remaining:>6,} unique types
    
    ════════════════════════════════════════════════════════════════════════════════
    """
    
    ax_summary.text(0.05, 0.95, summary_text, transform=ax_summary.transAxes, fontsize=10,
             verticalalignment='top', fontfamily='monospace',
             bbox=dict(boxstyle='round', facecolor='#f8f9fa', edgecolor='#dee2e6'))
    
    # Top right: Comparison bar chart - ONLY Total
    ax_comparison = fig.add_subplot(gs[0, 1])
    categories = ['Total']
    main_values = [main_counts.get(c, 0) for c in categories]
    current_values = [current_counts.get(c, 0) for c in categories]
    
    x = range(len(categories))
    width = 0.5
    
    bars1 = ax_comparison.bar([i - width/2 for i in x], main_values, width, 
                    label=main_branch, color='#3498db', alpha=0.8)
    bars2 = ax_comparison.bar([i + width/2 for i in x], current_values, width,
                    label=current_branch, color='#e74c3c', alpha=0.8)
    
    ax_comparison.set_ylabel('Count', fontsize=11)
    ax_comparison.set_title('Total Error Count Comparison', fontsize=12, fontweight='bold')
    ax_comparison.set_xticks(x)
    ax_comparison.set_xticklabels(categories)
    ax_comparison.legend(fontsize=10)
    ax_comparison.grid(axis='y', alpha=0.3)
    
    # Add value labels on bars
    for bars in [bars1, bars2]:
        for bar in bars:
            height = bar.get_height()
            if height > 0:
                ax_comparison.text(bar.get_x() + bar.get_width()/2., height,
                        f'{int(height):,}',
                        ha='center', va='bottom', fontsize=11, fontweight='bold')
    
    # Bottom left: Fixed and New errors (side by side)
    # Use nested GridSpec within the bottom left cell
    gs_bottom_left = gs[1, 0].subgridspec(1, 2, wspace=0.2)
    
    # Fixed errors pie chart
    ax_fixed = fig.add_subplot(gs_bottom_left[0, 0])
    if total_fixed > 0:
        fixed_list = list(fixed_errors)[:10]
        fixed_counts = [diff_data["fixed_details"][err]["main_count"] for err in fixed_list]
        labels = [f"{msg[:20]}..." if len(msg) > 20 else msg for _, msg in fixed_list]
        
        fixed_colors = ['#2ecc71'] * len(fixed_list)
        wedges, texts, autotexts = ax_fixed.pie(
            fixed_counts,
            labels=labels,
            autopct=lambda p: f'{p:.1f}%' if p > 3 else '',
            colors=fixed_colors,
            startangle=90
        )
        ax_fixed.set_title(f'Errors Fixed\n({total_fixed} unique types)', 
                     fontsize=11, fontweight='bold')
    else:
        ax_fixed.text(0.5, 0.5, 'No errors fixed', transform=ax_fixed.transAxes,
                ha='center', va='center', fontsize=12, style='italic')
        ax_fixed.set_title('Errors Fixed', fontsize=11, fontweight='bold')
    
    # New errors pie chart
    ax_new = fig.add_subplot(gs_bottom_left[0, 1])
    if total_new > 0:
        new_list = list(new_errors)[:10]
        new_counts = [diff_data["new_details"][err]["current_count"] for err in new_list]
        labels = [f"{msg[:20]}..." if len(msg) > 20 else msg for _, msg in new_list]
        
        new_colors = ['#e74c3c'] * len(new_list)
        wedges, texts, autotexts = ax_new.pie(
            new_counts,
            labels=labels,
            autopct=lambda p: f'{p:.1f}%' if p > 3 else '',
            colors=new_colors,
            startangle=90
        )
        ax_new.set_title(f'New Errors\n({total_new} unique types)', 
                     fontsize=11, fontweight='bold')
    else:
        ax_new.text(0.5, 0.5, 'No new errors', transform=ax_new.transAxes,
                ha='center', va='center', fontsize=12, style='italic')
        ax_new.set_title('New Errors', fontsize=11, fontweight='bold')
    
    # Bottom right: Two pie charts side by side (horizontal)
    # Use nested GridSpec within the bottom right cell
    gs_bottom_right = gs[1, 1].subgridspec(1, 2, wspace=0.2)
    
    # Main branch error distribution (left)
    ax_main_pie = fig.add_subplot(gs_bottom_right[0, 0])
    create_error_pie_chart(main_results, ax_main_pie, f'{main_branch}', colors)
    
    # Current branch error distribution (right)
    ax_current_pie = fig.add_subplot(gs_bottom_right[0, 1])
    create_error_pie_chart(current_results, ax_current_pie, f'{current_branch}', colors)
    
    plt.tight_layout()
    plt.subplots_adjust(top=0.94)
    
    # Save the figure
    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
    plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
    print(f"\n📊 Diff report saved to: {output_path}")
    
    plt.close()


def print_terminal_report(
    diff_data: Dict[str, any],
    current_branch: str,
    main_branch: str,
    current_lines: int = 0,
    main_lines: int = 0
) -> None:
    """Print a detailed text report to terminal."""
    
    fixed_errors = diff_data["fixed_errors"]
    new_errors = diff_data["new_errors"]
    remaining_errors = diff_data["remaining_errors"]
    current_counts = diff_data["current_counts"]
    main_counts = diff_data["main_counts"]
    
    print("\n" + "=" * 80)
    print("TYPE CHECKER ERROR DIFF REPORT")
    print("=" * 80)
    print(f"\nComparing: {current_branch} vs {main_branch}\n")
    
    # Summary
    print("-" * 80)
    print("SUMMARY")
    print("-" * 80)
    if current_lines > 0 or main_lines > 0:
        print(f"Output file lines:")
        print(f"  Main branch ({main_branch}):     {main_lines:>6,} lines")
        print(f"  Current branch ({current_branch}): {current_lines:>6,} lines")
        print(f"  Net change:                    {current_lines - main_lines:>+6,} lines")
        print()
    print(f"Total errors:")
    print(f"  Main branch ({main_branch}):     {main_counts['Total']:,} errors")
    print(f"  Current branch ({current_branch}): {current_counts['Total']:,} errors")
    print(f"  Net change:                    {current_counts['Total'] - main_counts['Total']:+,} errors")
    print()
    
    # Unified table: All errors from both branches
    print("=" * 80)
    print("COMPLETE ERROR DIFF TABLE - All Errors from Both Branches")
    print("=" * 80)
    
    # Collect all errors from both branches
    all_errors = set()
    
    # Add fixed errors (in main, not in current)
    for level, msg in fixed_errors:
        all_errors.add((level, msg))
    
    # Add new errors (in current, not in main)
    for level, msg in new_errors:
        all_errors.add((level, msg))
    
    # Add remaining errors (in both)
    for level, msg in remaining_errors:
        all_errors.add((level, msg))
    
    if all_errors:
        # Build unified list with all error details
        unified_errors = []
        for level, msg in all_errors:
            if (level, msg) in fixed_errors:
                # Error only in main (removed)
                details = diff_data["fixed_details"][(level, msg)]
                main_count = details["main_count"]
                current_count = 0
                diff = -main_count  # Negative because it was removed
            elif (level, msg) in new_errors:
                # Error only in current (introduced)
                details = diff_data["new_details"][(level, msg)]
                main_count = 0
                current_count = details["current_count"]
                diff = current_count  # Positive because it was introduced
            else:
                # Error in both branches
                details = diff_data["remaining_details"][(level, msg)]
                main_count = details["main_count"]
                current_count = details["current_count"]
                diff = details["diff"]
            
            unified_errors.append((level, msg, main_count, current_count, diff))
        
        # Sort by absolute diff (largest changes first), then by current count
        unified_sorted = sorted(
            unified_errors,
            key=lambda x: (abs(x[4]), x[2]),  # Sort by abs diff, then main count
            reverse=True
        )
        
        # Calculate totals
        total_main = sum(main_count for _, _, main_count, _, _ in unified_sorted)
        total_current = sum(current_count for _, _, _, current_count, _ in unified_sorted)
        total_diff = sum(diff for _, _, _, _, diff in unified_sorted)
        
        print(f"\nTotal unique error types: {len(unified_sorted)}")
        print(f"Total errors in main branch:     {total_main:,}")
        print(f"Total errors in current branch:  {total_current:,}")
        print(f"Net change:                      {total_diff:+,}\n")
        
        print(f"{'Main':>8} | {'Current':>8} | {'Diff':>8} | {'Level':<15} | Error Message")
        print("-" * 80)
        
        for level, msg, main_count, current_count, diff in unified_sorted:
            # Truncate long messages
            display_msg = msg[:60] + "..." if len(msg) > 60 else msg
            print(f"{main_count:>8,} | {current_count:>8,} | {diff:>+8,} | {level:<15} | {display_msg}")
        
        # Summary breakdown
        print("\n" + "-" * 80)
        print("SUMMARY BREAKDOWN")
        print("-" * 80)
        removed_count = sum(1 for _, _, main_count, current_count, _ in unified_sorted if main_count > 0 and current_count == 0)
        introduced_count = sum(1 for _, _, main_count, current_count, _ in unified_sorted if main_count == 0 and current_count > 0)
        changed_count = sum(1 for _, _, main_count, current_count, diff in unified_sorted if main_count > 0 and current_count > 0 and diff != 0)
        unchanged_count = sum(1 for _, _, main_count, current_count, diff in unified_sorted if main_count > 0 and current_count > 0 and diff == 0)
        
        print(f"Errors removed (main only):        {removed_count:>4,} unique types")
        print(f"Errors introduced (current only):  {introduced_count:>4,} unique types")
        print(f"Errors changed (both, diff != 0):   {changed_count:>4,} unique types")
        print(f"Errors unchanged (both, same):      {unchanged_count:>4,} unique types")
    else:
        print("\n  No errors found in either branch.")
    print()


def main():
    parser = argparse.ArgumentParser(
        description="Generate diff report comparing type checker errors between branches"
    )
    parser.add_argument(
        "--current-branch",
        type=str,
        help="Current branch name (default: detected from git)"
    )
    parser.add_argument(
        "--main-branch",
        type=str,
        default="main",
        help="Main branch name (default: main)"
    )
    parser.add_argument(
        "--skip-checkout",
        action="store_true",
        help="Skip git checkout (useful if already on correct branches)"
    )
    
    args = parser.parse_args()
    
    # Get current branch
    if args.current_branch:
        current_branch = args.current_branch
    else:
        try:
            result = subprocess.run(
                ["git", "branch", "--show-current"],
                capture_output=True,
                text=True,
                check=True
            )
            current_branch = result.stdout.strip()
        except subprocess.CalledProcessError:
            print("Error: Could not determine current branch. Please specify --current-branch")
            sys.exit(1)
    
    main_branch = args.main_branch
    
    print("=" * 80)
    print("TYPE CHECKER ERROR DIFF REPORT GENERATOR")
    print("=" * 80)
    print(f"\nCurrent branch: {current_branch}")
    print(f"Main branch:    {main_branch}\n")
    
    # Step 0: Delete .jaccache folders
    print("Step 0: Cleaning .jaccache folders...")
    deleted_count = delete_jaccache_folders()
    print(f"  Deleted {deleted_count} .jaccache folder(s)")
    
    # Step 1: Run check on current branch
    print("\nStep 1: Running type check on current branch...")
    current_output = "build/out_current"
    
    # Count lines before (if file exists)
    lines_before_current = count_lines(current_output)
    if lines_before_current > 0:
        print(f"  Output file exists with {lines_before_current:,} lines (will be overwritten)")
    
    if not run_jac_check(current_output):
        print("  Warning: jac check returned non-zero exit code (expected if there are errors)")

    
    # Count lines after
    current_lines = count_lines(current_output)
    print(f"  Generated output file with {current_lines:,} lines")
    
    # Process current branch errors
    print("  Processing errors...")
    current_results = process_error_file(current_output)
    current_counts = get_error_counts(current_results)
    print(f"  Found {current_counts['Total']:,} total errors")
    
    # Step 2: Checkout main branch
    if not args.skip_checkout:
        print(f"\nStep 2: Checking out {main_branch} branch...")
        try:
            subprocess.run(
                ["git", "checkout", main_branch],
                check=True,
                capture_output=True
            )
            print(f"  Switched to {main_branch} branch")
        except subprocess.CalledProcessError as e:
            print(f"  Error checking out {main_branch}: {e}")
            sys.exit(1)
    
    # Step 2.5: Delete .jaccache folders again after checkout
    print("\nStep 2.5: Cleaning .jaccache folders after checkout...")
    deleted_count = delete_jaccache_folders()
    print(f"  Deleted {deleted_count} .jaccache folder(s)")
    
    # Step 3: Run check on main branch
    print(f"\nStep 3: Running type check on {main_branch} branch...")
    main_output = "build/out_main"
    
    # Count lines before (if file exists)
    lines_before_main = count_lines(main_output)
    if lines_before_main > 0:
        print(f"  Output file exists with {lines_before_main:,} lines (will be overwritten)")
    
    if not run_jac_check(main_output):
        print("  Warning: jac check returned non-zero exit code (expected if there are errors)")
    
    # Count lines after
    main_lines = count_lines(main_output)
    print(f"  Generated output file with {main_lines:,} lines")
    
    # Process main branch errors
    print("  Processing errors...")
    main_results = process_error_file(main_output)
    main_counts = get_error_counts(main_results)
    print(f"  Found {main_counts['Total']:,} total errors")
    
    # Step 4: Checkout back to original branch
    if not args.skip_checkout:
        print(f"\nStep 4: Checking out back to {current_branch} branch...")
        try:
            subprocess.run(
                ["git", "checkout", current_branch],
                check=True,
                capture_output=True
            )
            print(f"  Switched back to {current_branch} branch")
        except subprocess.CalledProcessError as e:
            print(f"  Warning: Could not checkout back to {current_branch}: {e}")
            print("  Please manually checkout your branch")
    
    # Step 5: Compare and generate report
    print("\nStep 5: Comparing errors and generating report...")
    diff_data = compare_errors(current_results, main_results)
    
    # Generate visual report with line counts and pie charts
    output_path = "build/error_diff_report.png"
    generate_diff_report(
        diff_data, 
        current_branch, 
        main_branch, 
        current_results,
        main_results,
        current_lines,
        main_lines,
        output_path
    )
    
    # Print terminal report (includes line counts)
    print_terminal_report(diff_data, current_branch, main_branch, current_lines, main_lines)
    
    print("\n" + "=" * 80)
    print("Report generation complete!")
    print("=" * 80)


if __name__ == "__main__":
    main()

[ThakeeNathees]

run this one the fetaure branch with
python file.py jac_check_result_file_path

#!/usr/bin/env python3
"""
Script to filter and extract unique error types from linting output.
Normalizes error messages to identify underlying error patterns.
Generates a visual report with pie charts.

Usage:
    python filter_unique_errors.py <path_to_error_file>
    
    Generate the error file with: jac check . 2>&1 | tee out
"""

import re
import sys
import shutil
from collections import Counter
from pathlib import Path

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches


def normalize_message(message: str) -> str:
    """Normalize an error message by replacing variable parts with placeholders."""
    
    # Replace jaclang type objects: <jaclang.compiler.type_system.types.XYZ object at 0x...>
    message = re.sub(
        r"<jaclang\.compiler\.type_system\.types\.\w+ object at 0x[0-9a-fA-F]+>",
        "<TYPE_OBJ>",
        message
    )
    
    # Replace <class XYZ> patterns
    message = re.sub(r"<class \w+>", "<TYPE>", message)
    
    # Replace quoted parameter/variable names like 'name', 'x', 'args'
    message = re.sub(r"'[a-zA-Z_][a-zA-Z0-9_]*'", "'PARAM'", message)
    
    # Replace quoted string tokens like '"Circle"', '"Unknown"'
    message = re.sub(r'"[^"]*"', '"TOKEN"', message)
    
    # Replace file paths in error checking messages
    message = re.sub(
        r"Could not read file [^:]+:",
        "Could not read file <FILE>:",
        message
    )
    
    # Normalize directory error paths
    message = re.sub(
        r"\[Errno 21\] Is a directory: '[^']*'",
        "[Errno 21] Is a directory: '<DIR>'",
        message
    )
    
    return message.strip()


def should_ignore(line: str, message: str) -> bool:
    """Check if a line/message should be ignored."""
    
    # Ignore "Module not found" warnings
    if message == "Module not found":
        return True
    
    # Ignore "Unexpected token" errors
    if message.startswith("Unexpected token"):
        return True
    
    # Ignore byllm plugin patch messages
    if "Please install a byllm plugin, but for now patching byllm.lib with NonGPT" in line:
        return True
    
    return False


def extract_message(line: str) -> tuple[str, str] | None:
    """
    Extract the error/warning type and message from a line.
    Returns (level, message) or None if not a valid error/warning line.
    """
    
    # Pattern 1: Error: <file>, line X, col Y: <message>
    # Pattern 2: Warning: <file>, line X, col Y: <message>
    match = re.match(r"^(Error|Warning): .+, line \d+, col \d+: (.+)$", line)
    if match:
        return match.group(1), match.group(2)
    
    # Pattern 3: Error checking '<file>': <message>
    match = re.match(r"^Error checking '[^']+': (.+)$", line)
    if match:
        return "Error checking", match.group(1)
    
    return None


def process_file(filepath: str) -> dict[str, Counter]:
    """Process the error file and return counts of unique error types."""
    
    results: dict[str, Counter] = {
        "Error": Counter(),
        "Warning": Counter(),
        "Error checking": Counter(),
    }
    
    with open(filepath, "r") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            
            # Skip byllm plugin patch messages
            if "Please install a byllm plugin" in line:
                continue
            
            extracted = extract_message(line)
            if extracted:
                level, message = extracted
                
                # Skip ignored messages
                if should_ignore(line, message):
                    continue
                
                normalized = normalize_message(message)
                results[level][normalized] += 1
    
    return results


def generate_report(results: dict[str, Counter], output_path: str = "error_report.png"):
    """Generate a visual report with pie charts and statistics."""
    
    # Combine all errors for the main pie chart
    all_errors = results["Error"] + results["Error checking"]
    total_errors = sum(all_errors.values())
    
    if total_errors == 0:
        print("No errors to visualize!")
        return
    
    # Sort by count and get top errors
    sorted_errors = sorted(all_errors.items(), key=lambda x: -x[1])
    
    # Group smaller errors into "Other" category for cleaner pie chart
    top_n = 10
    top_errors = sorted_errors[:top_n]
    other_count = sum(count for _, count in sorted_errors[top_n:])
    
    if other_count > 0:
        top_errors.append(("Other errors", other_count))
    
    # Prepare data for pie chart
    labels = []
    sizes = []
    for msg, count in top_errors:
        # Truncate long labels
        label = msg[:40] + "..." if len(msg) > 40 else msg
        labels.append(f"{label}\n({count})")
        sizes.append(count)
    
    # Calculate percentages
    percentages = [s / total_errors * 100 for s in sizes]
    
    # Color palette
    colors = [
        '#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6',
        '#1abc9c', '#e67e22', '#34495e', '#16a085', '#c0392b',
        '#7f8c8d'
    ]
    
    # Create figure with grid layout
    fig = plt.figure(figsize=(20, 12))
    fig.suptitle('Linting Error Analysis Report', fontsize=16, fontweight='bold', y=0.98)
    
    # Use GridSpec for better control
    gs = fig.add_gridspec(2, 3, width_ratios=[1.2, 0.8, 1], height_ratios=[1, 1], 
                          hspace=0.3, wspace=0.3)
    
    # Main pie chart (top-left, spans 2 rows)
    ax1 = fig.add_subplot(gs[:, 0])
    wedges, texts, autotexts = ax1.pie(
        sizes,
        colors=colors[:len(sizes)],
        autopct=lambda p: f'{p:.1f}%' if p > 3 else '',
        startangle=90,
        pctdistance=0.75,
        explode=[0.02] * len(sizes)
    )
    
    # Style the percentage text
    for autotext in autotexts:
        autotext.set_fontsize(9)
        autotext.set_fontweight('bold')
        autotext.set_color('white')
    
    ax1.set_title(f'Error Distribution (Top {top_n})\nTotal: {total_errors} errors', 
                  fontsize=12, fontweight='bold', pad=20)
    
    # Legend in separate subplot (middle column, spans 2 rows)
    ax_legend = fig.add_subplot(gs[:, 1])
    ax_legend.axis('off')
    
    legend_labels = [f"{labels[i].split(chr(10))[0]}: {sizes[i]} ({percentages[i]:.1f}%)" 
                     for i in range(len(labels))]
    
    # Create legend patches manually
    legend_patches = [mpatches.Patch(color=colors[i], label=legend_labels[i]) 
                      for i in range(len(legend_labels))]
    ax_legend.legend(handles=legend_patches, title="Error Types", loc="center",
                     fontsize=9, title_fontsize=11, frameon=True, 
                     facecolor='#f8f9fa', edgecolor='#dee2e6')
    
    # Right side: Statistics table (top-right)
    ax2 = fig.add_subplot(gs[0, 2])
    ax2.axis('off')
    
    # Summary statistics
    total_unique = len(results["Error"]) + len(results["Error checking"])
    stats_text = f"""
    SUMMARY STATISTICS
    ══════════════════════════════════════
    
    Total Errors:           {total_errors:,}
    Unique Error Types:     {total_unique}
    
    ─────────────────────────────────────
    Category Breakdown:
    ─────────────────────────────────────
    • Type Errors:          {sum(results["Error"].values()):,}
      ({len(results["Error"])} unique types)
    
    • Error Checking:       {sum(results["Error checking"].values()):,}
      ({len(results["Error checking"])} unique types)
    
    ─────────────────────────────────────
    Top 5 Most Common:
    ─────────────────────────────────────
    """
    
    for i, (msg, count) in enumerate(sorted_errors[:5], 1):
        short_msg = msg[:35] + "..." if len(msg) > 35 else msg
        pct = count / total_errors * 100
        stats_text += f"\n    {i}. {short_msg}\n       Count: {count} ({pct:.1f}%)\n"
    
    ax2.text(0.1, 0.95, stats_text, transform=ax2.transAxes, fontsize=9,
             verticalalignment='top', fontfamily='monospace',
             bbox=dict(boxstyle='round', facecolor='#f8f9fa', edgecolor='#dee2e6'))
    
    # Bottom right: Horizontal bar chart of top errors
    ax3 = fig.add_subplot(gs[1, 2])
    
    bar_data = sorted_errors[:8]
    bar_labels = [msg[:30] + "..." if len(msg) > 30 else msg for msg, _ in bar_data]
    bar_values = [count for _, count in bar_data]
    bar_colors = colors[:len(bar_data)]
    
    y_pos = range(len(bar_labels))
    bars = ax3.barh(y_pos, bar_values, color=bar_colors, edgecolor='white', linewidth=0.5)
    ax3.set_yticks(y_pos)
    ax3.set_yticklabels(bar_labels, fontsize=8)
    ax3.invert_yaxis()
    ax3.set_xlabel('Count', fontsize=10)
    ax3.set_title('Top 8 Error Types by Count', fontsize=11, fontweight='bold')
    
    # Add count labels on bars
    for bar, val in zip(bars, bar_values):
        ax3.text(bar.get_width() + 5, bar.get_y() + bar.get_height()/2,
                 f'{val}', va='center', fontsize=8, fontweight='bold')
    
    ax3.set_xlim(0, max(bar_values) * 1.15)
    ax3.spines['top'].set_visible(False)
    ax3.spines['right'].set_visible(False)
    
    plt.tight_layout()
    plt.subplots_adjust(top=0.93)
    
    # Save the figure
    plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
    print(f"\n📊 Report saved to: {output_path}")
    
    # Also show the plot
    plt.show()


def delete_jaccache_folders(root_path: str = ".") -> int:
    """Delete all .jaccache folders recursively. Returns count of deleted folders."""
    root = Path(root_path)
    deleted_count = 0
    
    for jaccache_dir in root.rglob(".jaccache"):
        if jaccache_dir.is_dir():
            try:
                shutil.rmtree(jaccache_dir)
                deleted_count += 1
                print(f"  Deleted: {jaccache_dir}")
            except Exception as e:
                print(f"  Warning: Could not delete {jaccache_dir}: {e}")
    
    return deleted_count


def main():
    # Require file path argument
    if len(sys.argv) < 2:
        print("Usage: python filter_unique_errors.py <path_to_error_file>")
        print("\nGenerate the error file with:")
        print("  jac check . 2>&1 | tee out")
        sys.exit(1)
    
    # Clean .jaccache folders before processing
    print("Cleaning .jaccache folders...")
    deleted_count = delete_jaccache_folders()
    print(f"Deleted {deleted_count} .jaccache folder(s)\n")
    
    filepath = sys.argv[1]
    
    if not Path(filepath).exists():
        print(f"Error: File not found: {filepath}")
        sys.exit(1)
    
    print(f"📂 Reading: {filepath}")
    
    # Process the file
    results = process_file(filepath)
    
    # Print summary
    total_errors = sum(results["Error"].values())
    total_warnings = sum(results["Warning"].values())
    total_checking = sum(results["Error checking"].values())
    
    print("\n" + "=" * 80)
    print("UNIQUE ERROR TYPES SUMMARY")
    print("=" * 80)
    print(f"\nTotal lines: {total_errors + total_warnings + total_checking}")
    print(f"  - Errors: {total_errors} ({len(results['Error'])} unique types)")
    print(f"  - Warnings: {total_warnings} ({len(results['Warning'])} unique types)")
    print(f"  - Error checking: {total_checking} ({len(results['Error checking'])} unique types)")
    
    # Print Errors
    print("\n" + "=" * 80)
    print("UNIQUE ERROR TYPES")
    print("=" * 80)
    for msg, count in sorted(results["Error"].items(), key=lambda x: -x[1]):
        print(f"  [{count:4d}] {msg}")
    
    # Print Warnings
    if results["Warning"]:
        print("\n" + "=" * 80)
        print("UNIQUE WARNING TYPES")
        print("=" * 80)
        for msg, count in sorted(results["Warning"].items(), key=lambda x: -x[1]):
            print(f"  [{count:4d}] {msg}")
    
    # Print Error checking
    if results["Error checking"]:
        print("\n" + "=" * 80)
        print("UNIQUE 'ERROR CHECKING' TYPES")
        print("=" * 80)
        for msg, count in sorted(results["Error checking"].items(), key=lambda x: -x[1]):
            print(f"  [{count:4d}] {msg}")
    
    # Generate visual report
    output_dir = Path(filepath).parent
    report_path = output_dir / "error_report.png"
    generate_report(results, str(report_path))


if __name__ == "__main__":
    main()

[kugesan1105]

Positive error

cl def app() -> Any{
    return <div>
    </div>;
}
cl def app2() {
    return <div>
    </div>;
}
cl def app3()-> any {
    return <div>
    </div>;
}
cl def app4()->JsxElement {
    return <div>
    </div>;
}