depyler-core 4.1.1

//! Wave 6 coverage tests: type_helpers.rs, lambda_generators.rs, method_call_routing.rs,
//! instance_dispatch.rs, dict_constructors.rs
//!
//! Targets the largest coverage gaps in expr_gen_instance_methods:
//! - type_helpers.rs (447 missed, 62.1% covered)
//! - lambda_generators.rs (309 missed, 59.1%)
//! - method_call_routing.rs (290 missed, 66.3%)
//! - instance_dispatch.rs (192 missed, 65.1%)
//! - dict_constructors.rs (181 missed, 60.6%)

#[cfg(test)]
mod tests {
    use crate::DepylerPipeline;

    fn transpile(code: &str) -> String {
        let pipeline = DepylerPipeline::new();
        pipeline.transpile(code).expect("transpile")
    }

    fn transpile_ok(code: &str) -> bool {
        let pipeline = DepylerPipeline::new();
        pipeline.transpile(code).is_ok()
    }

    // ========================================================================
    // SECTION 1: type_helpers.rs - is_string_variable
    // ========================================================================

    #[test]
    fn test_w6_string_var_named_key() {
        let result = transpile("def f(d: dict) -> str:\n    key = \"hello\"\n    return d[key]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_named_name() {
        let result = transpile("def f(d: dict) -> str:\n    name = \"alice\"\n    return d[name]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_named_id() {
        let result = transpile("def f(d: dict) -> str:\n    id = \"abc\"\n    return d[id]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_named_word() {
        let result = transpile("def f(d: dict) -> str:\n    word = \"test\"\n    return d[word]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_named_text() {
        let result = transpile("def f(d: dict) -> str:\n    text = \"data\"\n    return d[text]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_suffix_key() {
        let result = transpile("def f(d: dict) -> str:\n    cache_key = \"k1\"\n    return d[cache_key]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_suffix_name() {
        let result = transpile("def f(d: dict) -> str:\n    user_name = \"bob\"\n    return d[user_name]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_k_loop() {
        let result = transpile("def f(d: dict) -> list:\n    result = []\n    for k in d:\n        result.append(d[k])\n    return result\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_chr_call() {
        let result = transpile("def f(n: int) -> str:\n    return chr(n)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_str_call() {
        let result = transpile("def f(n: int) -> str:\n    return str(n)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_repr_call() {
        let result = transpile("def f(x: int) -> str:\n    return repr(x)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_hex_call() {
        let result = transpile("def f(n: int) -> str:\n    return hex(n)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_method_upper() {
        let result = transpile("def f(s: str) -> str:\n    return s.upper()\n");
        assert!(!result.is_empty());
        assert!(result.contains("to_uppercase") || result.contains("upper"));
    }

    #[test]
    fn test_w6_string_var_from_method_lower() {
        let result = transpile("def f(s: str) -> str:\n    return s.lower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_method_strip() {
        let result = transpile("def f(s: str) -> str:\n    return s.strip()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_method_replace() {
        let result = transpile("def f(s: str) -> str:\n    return s.replace(\"a\", \"b\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_var_from_method_join() {
        let result = transpile("def f(items: list) -> str:\n    return \",\".join(items)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 2: type_helpers.rs - is_numeric_index
    // ========================================================================

    #[test]
    fn test_w6_numeric_index_literal_int() {
        let result = transpile("def f(lst: list) -> int:\n    return lst[0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_var_i() {
        let result = transpile("def f(lst: list) -> int:\n    i = 0\n    return lst[i]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_var_j() {
        let result = transpile("def f(lst: list) -> int:\n    j = 1\n    return lst[j]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_var_idx() {
        let result = transpile("def f(lst: list) -> int:\n    idx = 2\n    return lst[idx]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_var_index() {
        let result = transpile("def f(lst: list) -> int:\n    index = 3\n    return lst[index]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_suffix_idx() {
        let result = transpile("def f(lst: list) -> int:\n    start_idx = 0\n    return lst[start_idx]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_suffix_index() {
        let result = transpile("def f(lst: list) -> int:\n    start_index = 0\n    return lst[start_index]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_numeric_index_binary_expr() {
        let result = transpile("def f(lst: list, n: int) -> int:\n    return lst[n + 1]\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 3: type_helpers.rs - is_dict_expr
    // ========================================================================

    #[test]
    fn test_w6_dict_expr_literal() {
        let result = transpile("def f() -> dict:\n    d = {\"a\": 1}\n    return d\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_dict_call() {
        let result = transpile("def f() -> dict:\n    d = dict()\n    return d\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_typed_var() {
        let result = transpile("def f(d: dict) -> int:\n    return len(d)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_get_method() {
        let result = transpile("def f(d: dict) -> int:\n    return d.get(\"key\", 0)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_keys_method() {
        let result = transpile("def f(d: dict) -> list:\n    return list(d.keys())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_values_method() {
        let result = transpile("def f(d: dict) -> list:\n    return list(d.values())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_items_method() {
        let result = transpile("def f(d: dict) -> list:\n    result = []\n    for k, v in d.items():\n        result.append(k)\n    return result\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_expr_update_method() {
        let result = transpile("def f(d: dict) -> dict:\n    d.update({\"b\": 2})\n    return d\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 4: type_helpers.rs - is_set_expr
    // ========================================================================

    #[test]
    fn test_w6_set_expr_literal() {
        let result = transpile("def f() -> set:\n    s = {1, 2, 3}\n    return s\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_set_call() {
        let result = transpile("def f() -> set:\n    s = set()\n    return s\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_add_method() {
        let result = transpile("def f() -> set:\n    s = set()\n    s.add(1)\n    return s\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_discard_method() {
        let result = transpile("def f(s: set) -> set:\n    s.discard(1)\n    return s\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_union() {
        let result = transpile("def f(a: set, b: set) -> set:\n    return a.union(b)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_intersection() {
        let result = transpile("def f(a: set, b: set) -> set:\n    return a.intersection(b)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_difference() {
        let result = transpile("def f(a: set, b: set) -> set:\n    return a.difference(b)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_symmetric_difference() {
        let result = transpile("def f(a: set, b: set) -> set:\n    return a.symmetric_difference(b)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_issubset() {
        let result = transpile("def f(a: set, b: set) -> bool:\n    return a.issubset(b)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_issuperset() {
        let result = transpile("def f(a: set, b: set) -> bool:\n    return a.issuperset(b)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_expr_isdisjoint() {
        let result = transpile("def f(a: set, b: set) -> bool:\n    return a.isdisjoint(b)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 5: type_helpers.rs - is_path_expr
    // ========================================================================

    #[test]
    fn test_w6_path_expr_path_call() {
        let result = transpile("from pathlib import Path\ndef f() -> str:\n    p = Path(\"/tmp\")\n    return str(p)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_expr_var_named_path() {
        let result = transpile("from pathlib import Path\ndef f(path: str) -> str:\n    return path\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_expr_suffix_path() {
        let result = transpile("from pathlib import Path\ndef f(file_path: str) -> str:\n    return file_path\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_expr_dir_suffix() {
        let result = transpile("from pathlib import Path\ndef f(base_dir: str) -> str:\n    return base_dir\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_expr_parent_attr() {
        let result = transpile("from pathlib import Path\ndef f() -> str:\n    p = Path(\"/tmp/a\")\n    return str(p.parent)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 6: type_helpers.rs - is_string_type
    // ========================================================================

    #[test]
    fn test_w6_string_type_literal() {
        let result = transpile("def f() -> str:\n    return \"hello\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_type_var() {
        let result = transpile("def f(s: str) -> int:\n    return len(s)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_type_str_call() {
        let result = transpile("def f(n: int) -> int:\n    s = str(n)\n    return len(s)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_type_method_to_string() {
        let result = transpile("def f(n: int) -> str:\n    return str(n)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_type_stdout_attr() {
        let _ok = transpile_ok("import subprocess\ndef f() -> str:\n    r = subprocess.run([\"ls\"], capture_output=True)\n    return r.stdout\n");
    }

    // ========================================================================
    // SECTION 7: type_helpers.rs - is_string_base
    // ========================================================================

    #[test]
    fn test_w6_string_base_literal() {
        let result = transpile("def f() -> list:\n    return list(\"hello\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_text() {
        let result = transpile("def f(text: str) -> list:\n    return text.split(\" \")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_s() {
        let result = transpile("def f(s: str) -> list:\n    return s.split(\",\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_line() {
        let result = transpile("def f(line: str) -> list:\n    return line.split(\" \")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_content() {
        let result = transpile("def f(content: str) -> list:\n    return content.split(\"\\n\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_message() {
        let result = transpile("def f(message: str) -> str:\n    return message.upper()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_prefix() {
        let result = transpile("def f(prefix: str) -> str:\n    return prefix.upper()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_suffix() {
        let result = transpile("def f(suffix: str) -> str:\n    return suffix.lower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_delimiter() {
        let result = transpile("def f(delimiter: str, parts: list) -> str:\n    return delimiter.join(parts)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_pattern() {
        let result = transpile("def f(pattern: str) -> str:\n    return pattern.lower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_attr_text() {
        let _ok = transpile_ok("class Obj:\n    def __init__(self, text: str) -> None:\n        self.text = text\n    def upper(self) -> str:\n        return self.text.upper()\n");
    }

    // ========================================================================
    // SECTION 8: type_helpers.rs - is_tuple_base
    // ========================================================================

    #[test]
    fn test_w6_tuple_base_literal() {
        let result = transpile("def f() -> int:\n    t = (1, 2, 3)\n    return t[0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_tuple_base_var_pair() {
        let result = transpile("def f() -> int:\n    pair = (1, 2)\n    return pair[0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_tuple_base_var_tuple() {
        let result = transpile("def f() -> int:\n    t = (1, 2)\n    return t[0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_tuple_base_var_item() {
        let result = transpile("def f() -> int:\n    item = (1, 2)\n    return item[0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_tuple_base_var_row() {
        let result = transpile("def f() -> int:\n    row = (1, 2)\n    return row[0]\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 9: type_helpers.rs - expr_is_option
    // ========================================================================

    #[test]
    fn test_w6_expr_is_option_typed_var() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[int]) -> int:\n    if x is not None:\n        return x\n    return 0\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_expr_is_option_none_default() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[str] = None) -> str:\n    if x is not None:\n        return x\n    return \"\"\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 10: type_helpers.rs - type coercion helpers
    // ========================================================================

    #[test]
    fn test_w6_type_coercion_int_to_float() {
        let result = transpile("def f(x: int) -> float:\n    return float(x)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_coercion_float_to_int() {
        let result = transpile("def f(x: float) -> int:\n    return int(x)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_coercion_str_to_int() {
        let result = transpile("def f(s: str) -> int:\n    return int(s)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_coercion_str_to_float() {
        let result = transpile("def f(s: str) -> float:\n    return float(s)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 11: type_helpers.rs - is_list_expr
    // ========================================================================

    #[test]
    fn test_w6_list_expr_literal() {
        let result = transpile("def f() -> list:\n    return [1, 2, 3]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_expr_list_call() {
        let result = transpile("def f() -> list:\n    return list()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_append() {
        let result = transpile("def f() -> list:\n    lst = []\n    lst.append(1)\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_extend() {
        let result = transpile("def f(a: list, b: list) -> list:\n    a.extend(b)\n    return a\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_insert() {
        let result = transpile("def f() -> list:\n    lst = [1, 3]\n    lst.insert(1, 2)\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_remove() {
        let result = transpile("def f() -> list:\n    lst = [1, 2, 3]\n    lst.remove(2)\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_pop() {
        let result = transpile("def f() -> int:\n    lst = [1, 2, 3]\n    return lst.pop()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_sort() {
        let result = transpile("def f(lst: list) -> list:\n    lst.sort()\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_reverse() {
        let result = transpile("def f(lst: list) -> list:\n    lst.reverse()\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_index() {
        let result = transpile("def f(lst: list) -> int:\n    return lst.index(5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_count() {
        let result = transpile("def f(lst: list) -> int:\n    return lst.count(1)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_clear() {
        let result = transpile("def f(lst: list) -> list:\n    lst.clear()\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_copy() {
        let result = transpile("def f(lst: list) -> list:\n    return lst.copy()\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 12: lambda_generators.rs - lambda with captures
    // ========================================================================

    #[test]
    fn test_w6_lambda_no_params() {
        let result = transpile("def f() -> int:\n    fn = lambda: 42\n    return fn()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_single_param() {
        let result = transpile("def f() -> int:\n    fn = lambda x: x * 2\n    return fn(5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_multi_params() {
        let result = transpile("def f() -> int:\n    fn = lambda x, y: x + y\n    return fn(3, 4)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_with_capture() {
        let result = transpile("def f(offset: int) -> int:\n    fn = lambda x: x + offset\n    return fn(5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_with_string_capture() {
        let result = transpile("def f(prefix: str) -> str:\n    fn = lambda x: prefix + x\n    return fn(\"world\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_capture_list() {
        let result = transpile("def f() -> list:\n    items = [1, 2, 3]\n    fn = lambda x: items[x]\n    return [fn(0), fn(1)]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_in_sort_key() {
        let result = transpile("def f(lst: list) -> list:\n    lst.sort(key=lambda x: x[0])\n    return lst\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_in_map() {
        let result = transpile("def f(lst: list) -> list:\n    return list(map(lambda x: x * 2, lst))\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_in_filter() {
        let result = transpile("def f(lst: list) -> list:\n    return list(filter(lambda x: x > 0, lst))\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_nested_body() {
        let result = transpile("def f() -> int:\n    fn = lambda x: x if x > 0 else -x\n    return fn(-5)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 13: lambda_generators.rs - f-string generation
    // ========================================================================

    #[test]
    fn test_w6_fstring_simple_var() {
        let result = transpile("def f(name: str) -> str:\n    return f\"Hello {name}\"\n");
        assert!(!result.is_empty());
        assert!(result.contains("format!"));
    }

    #[test]
    fn test_w6_fstring_multiple_vars() {
        let result = transpile("def f(first: str, last: str) -> str:\n    return f\"{first} {last}\"\n");
        assert!(!result.is_empty());
        assert!(result.contains("format!"));
    }

    #[test]
    fn test_w6_fstring_expression() {
        let result = transpile("def f(x: int) -> str:\n    return f\"Result: {x + 1}\"\n");
        assert!(!result.is_empty());
        assert!(result.contains("format!"));
    }

    #[test]
    fn test_w6_fstring_empty() {
        let result = transpile("def f() -> str:\n    return f\"\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_no_expr() {
        let result = transpile("def f() -> str:\n    return f\"literal text\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_method_call() {
        let result = transpile("def f(s: str) -> str:\n    return f\"{s.upper()}\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_int() {
        let result = transpile("def f(n: int) -> str:\n    return f\"Number: {n}\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_float() {
        let result = transpile("def f(x: float) -> str:\n    return f\"Value: {x}\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_list_var() {
        let result = transpile("def f(items: list) -> str:\n    return f\"Items: {items}\"\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 14: lambda_generators.rs - ternary expressions
    // ========================================================================

    #[test]
    fn test_w6_ternary_simple() {
        let result = transpile("def f(x: int) -> int:\n    return x if x > 0 else -x\n");
        assert!(!result.is_empty());
        assert!(result.contains("if"));
    }

    #[test]
    fn test_w6_ternary_string() {
        let result = transpile("def f(flag: bool) -> str:\n    return \"yes\" if flag else \"no\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_ternary_none_default() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[int]) -> int:\n    return x if x is not None else 0\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_ternary_nested() {
        let result = transpile("def f(x: int) -> str:\n    return \"pos\" if x > 0 else \"zero\" if x == 0 else \"neg\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_ternary_with_call() {
        let result = transpile("def f(lst: list) -> int:\n    return len(lst) if lst else 0\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_ternary_float_coercion() {
        let result = transpile("def f(x: float) -> float:\n    return x / 2.0 if x > 0 else 0\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 15: lambda_generators.rs - truthiness checks for all types
    // ========================================================================

    #[test]
    fn test_w6_truthiness_string() {
        let result = transpile("def f(s: str) -> bool:\n    if s:\n        return True\n    return False\n");
        assert!(!result.is_empty());
        assert!(result.contains("is_empty") || result.contains("!"));
    }

    #[test]
    fn test_w6_truthiness_list() {
        let result = transpile("def f(lst: list) -> bool:\n    if lst:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_dict() {
        let result = transpile("def f(d: dict) -> bool:\n    if d:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_set() {
        let result = transpile("def f(s: set) -> bool:\n    if s:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_optional() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[int]) -> bool:\n    if x:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_int() {
        let result = transpile("def f(n: int) -> bool:\n    if n:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_float() {
        let result = transpile("def f(x: float) -> bool:\n    if x:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_bool() {
        let result = transpile("def f(b: bool) -> bool:\n    if b:\n        return True\n    return False\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_while_list() {
        let result = transpile("def f(lst: list) -> int:\n    count = 0\n    while lst:\n        lst.pop()\n        count = count + 1\n    return count\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_while_string() {
        let result = transpile("def f(s: str) -> int:\n    count = 0\n    while s:\n        s = s[1:]\n        count = count + 1\n    return count\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 16: lambda_generators.rs - sorted with key
    // ========================================================================

    #[test]
    fn test_w6_sorted_basic() {
        let result = transpile("def f(lst: list) -> list:\n    return sorted(lst)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_sorted_reverse() {
        let result = transpile("def f(lst: list) -> list:\n    return sorted(lst, reverse=True)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_sorted_key_lambda() {
        let result = transpile("def f(lst: list) -> list:\n    return sorted(lst, key=lambda x: x[0])\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_sorted_key_len() {
        let result = transpile("def f(words: list) -> list:\n    return sorted(words, key=len)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_sorted_key_abs() {
        let result = transpile("def f(nums: list) -> list:\n    return sorted(nums, key=abs)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 17: lambda_generators.rs - yield
    // ========================================================================

    #[test]
    fn test_w6_yield_simple() {
        let _ok = transpile_ok("def gen():\n    yield 1\n    yield 2\n    yield 3\n");
    }

    #[test]
    fn test_w6_yield_in_loop() {
        let _ok = transpile_ok("def count_up(n: int):\n    i = 0\n    while i < n:\n        yield i\n        i = i + 1\n");
    }

    #[test]
    fn test_w6_yield_with_value() {
        let _ok = transpile_ok("def evens(n: int):\n    for i in range(n):\n        if i % 2 == 0:\n            yield i\n");
    }

    #[test]
    fn test_w6_yield_none() {
        let _ok = transpile_ok("def gen():\n    yield\n");
    }

    // ========================================================================
    // SECTION 18: lambda_generators.rs - generator expressions
    // ========================================================================

    #[test]
    fn test_w6_genexpr_sum() {
        let result = transpile("def f(lst: list) -> int:\n    return sum(x * x for x in lst)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_genexpr_any() {
        let result = transpile("def f(lst: list) -> bool:\n    return any(x > 0 for x in lst)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_genexpr_all() {
        let result = transpile("def f(lst: list) -> bool:\n    return all(x > 0 for x in lst)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_genexpr_max() {
        let result = transpile("def f(lst: list) -> int:\n    return max(x for x in lst)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_genexpr_min() {
        let result = transpile("def f(lst: list) -> int:\n    return min(x for x in lst)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_genexpr_with_condition() {
        let result = transpile("def f(lst: list) -> int:\n    return sum(x for x in lst if x > 0)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_genexpr_list() {
        let result = transpile("def f(lst: list) -> list:\n    return list(x * 2 for x in lst)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 19: lambda_generators.rs - await
    // ========================================================================

    #[test]
    fn test_w6_await_expression() {
        let _ok = transpile_ok("async def f() -> int:\n    result = await get_data()\n    return result\n");
    }

    // ========================================================================
    // SECTION 20: method_call_routing.rs - list method routing
    // ========================================================================

    #[test]
    fn test_w6_route_list_append_inferred() {
        let result = transpile("def f() -> list:\n    data = []\n    data.append(42)\n    return data\n");
        assert!(!result.is_empty());
        assert!(result.contains("push"));
    }

    #[test]
    fn test_w6_route_list_extend_inferred() {
        let result = transpile("def f() -> list:\n    data = []\n    data.extend([1, 2])\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_list_pop_inferred() {
        let result = transpile("def f() -> int:\n    data = [1, 2, 3]\n    return data.pop()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_list_sort_inferred() {
        let result = transpile("def f() -> list:\n    data = [3, 1, 2]\n    data.sort()\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_list_reverse_inferred() {
        let result = transpile("def f() -> list:\n    data = [1, 2, 3]\n    data.reverse()\n    return data\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 21: method_call_routing.rs - dict method routing
    // ========================================================================

    #[test]
    fn test_w6_route_dict_keys_inferred() {
        let result = transpile("def f() -> list:\n    data = {\"a\": 1}\n    return list(data.keys())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_dict_values_inferred() {
        let result = transpile("def f() -> list:\n    data = {\"a\": 1}\n    return list(data.values())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_dict_items_inferred() {
        let result = transpile("def f() -> list:\n    data = {\"a\": 1}\n    result = []\n    for k, v in data.items():\n        result.append(k)\n    return result\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_dict_get_inferred() {
        let result = transpile("def f() -> int:\n    data = {\"a\": 1}\n    return data.get(\"a\", 0)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_dict_setdefault_inferred() {
        let result = transpile("def f() -> int:\n    data = {}\n    data.setdefault(\"a\", 0)\n    return data[\"a\"]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_dict_update_inferred() {
        let result = transpile("def f() -> dict:\n    data = {\"a\": 1}\n    data.update({\"b\": 2})\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_dict_popitem_inferred() {
        let _ok = transpile_ok("def f() -> dict:\n    data = {\"a\": 1}\n    data.popitem()\n    return data\n");
    }

    // ========================================================================
    // SECTION 22: method_call_routing.rs - string method routing
    // ========================================================================

    #[test]
    fn test_w6_route_string_lower() {
        let result = transpile("def f(s: str) -> str:\n    return s.lower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_upper() {
        let result = transpile("def f(s: str) -> str:\n    return s.upper()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_strip() {
        let result = transpile("def f(s: str) -> str:\n    return s.strip()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_lstrip() {
        let result = transpile("def f(s: str) -> str:\n    return s.lstrip()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_rstrip() {
        let result = transpile("def f(s: str) -> str:\n    return s.rstrip()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_startswith() {
        let result = transpile("def f(s: str) -> bool:\n    return s.startswith(\"abc\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_endswith() {
        let result = transpile("def f(s: str) -> bool:\n    return s.endswith(\".py\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_split() {
        let result = transpile("def f(s: str) -> list:\n    return s.split(\",\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_splitlines() {
        let result = transpile("def f(s: str) -> list:\n    return s.splitlines()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_join() {
        let result = transpile("def f(parts: list) -> str:\n    return \"-\".join(parts)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_replace() {
        let result = transpile("def f(s: str) -> str:\n    return s.replace(\"old\", \"new\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_find() {
        let result = transpile("def f(s: str) -> int:\n    return s.find(\"x\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_rfind() {
        let result = transpile("def f(s: str) -> int:\n    return s.rfind(\"x\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_isdigit() {
        let result = transpile("def f(s: str) -> bool:\n    return s.isdigit()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_isalpha() {
        let result = transpile("def f(s: str) -> bool:\n    return s.isalpha()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_isalnum() {
        let result = transpile("def f(s: str) -> bool:\n    return s.isalnum()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_title() {
        let result = transpile("def f(s: str) -> str:\n    return s.title()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_center() {
        let result = transpile("def f(s: str) -> str:\n    return s.center(20)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_ljust() {
        let result = transpile("def f(s: str) -> str:\n    return s.ljust(20)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_rjust() {
        let result = transpile("def f(s: str) -> str:\n    return s.rjust(20)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_zfill() {
        let result = transpile("def f(s: str) -> str:\n    return s.zfill(10)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_encode() {
        let result = transpile("def f(s: str) -> bytes:\n    return s.encode()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_string_format() {
        let result = transpile("def f(name: str) -> str:\n    return \"Hello {}\".format(name)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 23: method_call_routing.rs - set method routing
    // ========================================================================

    #[test]
    fn test_w6_route_set_add_inferred() {
        let result = transpile("def f() -> set:\n    s = set()\n    s.add(1)\n    return s\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_set_discard_inferred() {
        let result = transpile("def f() -> set:\n    s = {1, 2, 3}\n    s.discard(2)\n    return s\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_set_intersection_update() {
        let result = transpile("def f(a: set, b: set) -> set:\n    a.intersection_update(b)\n    return a\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_route_set_difference_update() {
        let result = transpile("def f(a: set, b: set) -> set:\n    a.difference_update(b)\n    return a\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 24: method_call_routing.rs - type inference via method usage
    // ========================================================================

    #[test]
    fn test_w6_type_infer_append_list() {
        let result = transpile("def f():\n    data = []\n    data.append(\"hello\")\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_insert_list() {
        let result = transpile("def f():\n    data = []\n    data.insert(0, 42)\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_lower_string() {
        let result = transpile("def f(text):\n    return text.lower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_split_string() {
        let result = transpile("def f(text):\n    return text.split(\" \")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_keys_dict() {
        let result = transpile("def f(data):\n    return list(data.keys())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_values_dict() {
        let result = transpile("def f(data):\n    return list(data.values())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_add_set() {
        let result = transpile("def f():\n    data = set()\n    data.add(1)\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_type_infer_iter_list() {
        let _ok = transpile_ok("def f(data):\n    data.iter()\n");
    }

    // ========================================================================
    // SECTION 25: method_call_routing.rs - mut_option_params
    // ========================================================================

    #[test]
    fn test_w6_mut_option_is_none() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[int] = None) -> bool:\n    return x is None\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_mut_option_is_not_none() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[int] = None) -> bool:\n    return x is not None\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 26: method_call_routing.rs - dunder methods
    // ========================================================================

    #[test]
    fn test_w6_dunder_len() {
        let _ok = transpile_ok("class MyList:\n    def __init__(self) -> None:\n        self.items = []\n    def __len__(self) -> int:\n        return len(self.items)\n");
    }

    #[test]
    fn test_w6_dunder_str() {
        let _ok = transpile_ok("class Point:\n    def __init__(self, x: int, y: int) -> None:\n        self.x = x\n        self.y = y\n    def __str__(self) -> str:\n        return f\"({self.x}, {self.y})\"\n");
    }

    #[test]
    fn test_w6_dunder_eq() {
        let _ok = transpile_ok("class Point:\n    def __init__(self, x: int, y: int) -> None:\n        self.x = x\n        self.y = y\n    def __eq__(self, other) -> bool:\n        return self.x == other.x and self.y == other.y\n");
    }

    // ========================================================================
    // SECTION 27: instance_dispatch.rs - file operations
    // ========================================================================

    #[test]
    fn test_w6_file_read_no_args() {
        let _ok = transpile_ok("def f(path: str) -> str:\n    f = open(path, \"r\")\n    content = f.read()\n    f.close()\n    return content\n");
    }

    #[test]
    fn test_w6_file_read_with_size() {
        let _ok = transpile_ok("def f(path: str) -> bytes:\n    f = open(path, \"rb\")\n    chunk = f.read(8192)\n    f.close()\n    return chunk\n");
    }

    #[test]
    fn test_w6_file_readline() {
        let _ok = transpile_ok("def f(path: str) -> str:\n    f = open(path, \"r\")\n    line = f.readline()\n    f.close()\n    return line\n");
    }

    #[test]
    fn test_w6_file_readlines() {
        let _ok = transpile_ok("def f(path: str) -> list:\n    f = open(path, \"r\")\n    lines = f.readlines()\n    f.close()\n    return lines\n");
    }

    #[test]
    fn test_w6_file_write() {
        let _ok = transpile_ok("def f(path: str) -> None:\n    f = open(path, \"w\")\n    f.write(\"hello\")\n    f.close()\n");
    }

    #[test]
    fn test_w6_file_close() {
        let _ok = transpile_ok("def f(path: str) -> None:\n    f = open(path, \"r\")\n    f.close()\n");
    }

    #[test]
    fn test_w6_file_with_statement() {
        let result = transpile("def f(path: str) -> str:\n    with open(path, \"r\") as f:\n        return f.read()\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 28: instance_dispatch.rs - path methods
    // ========================================================================

    #[test]
    fn test_w6_path_stat() {
        let _ok = transpile_ok("from pathlib import Path\ndef f() -> None:\n    p = Path(\"/tmp\")\n    info = p.stat()\n");
    }

    #[test]
    fn test_w6_path_resolve() {
        let _ok = transpile_ok("from pathlib import Path\ndef f() -> str:\n    p = Path(\".\")\n    return str(p.resolve())\n");
    }

    #[test]
    fn test_w6_path_absolute() {
        let _ok = transpile_ok("from pathlib import Path\ndef f() -> str:\n    path = Path(\".\")\n    return str(path.absolute())\n");
    }

    #[test]
    fn test_w6_path_exists() {
        let result = transpile("from pathlib import Path\ndef f(path: str) -> bool:\n    p = Path(path)\n    return p.exists()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_is_file() {
        let result = transpile("from pathlib import Path\ndef f(path: str) -> bool:\n    p = Path(path)\n    return p.is_file()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_is_dir() {
        let result = transpile("from pathlib import Path\ndef f(path: str) -> bool:\n    p = Path(path)\n    return p.is_dir()\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 29: instance_dispatch.rs - datetime methods
    // ========================================================================

    #[test]
    fn test_w6_datetime_isoformat() {
        let _ok = transpile_ok("import datetime\ndef f() -> str:\n    dt = datetime.datetime.now()\n    return dt.isoformat()\n");
    }

    #[test]
    fn test_w6_datetime_strftime() {
        let _ok = transpile_ok("import datetime\ndef f() -> str:\n    dt = datetime.datetime.now()\n    return dt.strftime(\"%Y-%m-%d\")\n");
    }

    #[test]
    fn test_w6_datetime_timestamp() {
        let _ok = transpile_ok("import datetime\ndef f() -> float:\n    dt = datetime.datetime.now()\n    return dt.timestamp()\n");
    }

    #[test]
    fn test_w6_datetime_date() {
        let _ok = transpile_ok("import datetime\ndef f():\n    dt = datetime.datetime.now()\n    d = dt.date()\n    return d\n");
    }

    #[test]
    fn test_w6_datetime_time() {
        let _ok = transpile_ok("import datetime\ndef f():\n    dt = datetime.datetime.now()\n    t = dt.time()\n    return t\n");
    }

    #[test]
    fn test_w6_datetime_weekday() {
        let _ok = transpile_ok("import datetime\ndef f() -> int:\n    dt = datetime.datetime.now()\n    return dt.weekday()\n");
    }

    #[test]
    fn test_w6_datetime_isoweekday() {
        let _ok = transpile_ok("import datetime\ndef f() -> int:\n    dt = datetime.datetime.now()\n    return dt.isoweekday()\n");
    }

    // ========================================================================
    // SECTION 30: instance_dispatch.rs - csv methods
    // ========================================================================

    #[test]
    fn test_w6_csv_writeheader() {
        let _ok = transpile_ok("import csv\ndef f() -> None:\n    writer = csv.DictWriter(open(\"out.csv\", \"w\"), fieldnames=[\"a\", \"b\"])\n    writer.writeheader()\n");
    }

    #[test]
    fn test_w6_csv_writerow() {
        let _ok = transpile_ok("import csv\ndef f() -> None:\n    writer = csv.DictWriter(open(\"out.csv\", \"w\"), fieldnames=[\"a\"])\n    writer.writerow({\"a\": 1})\n");
    }

    // ========================================================================
    // SECTION 31: instance_dispatch.rs - regex groups
    // ========================================================================

    #[test]
    fn test_w6_regex_group_zero() {
        let _ok = transpile_ok("import re\ndef f(text: str) -> str:\n    m = re.search(\"abc\", text)\n    if m:\n        return m.group(0)\n    return \"\"\n");
    }

    #[test]
    fn test_w6_regex_group_numbered() {
        let _ok = transpile_ok("import re\ndef f(text: str) -> str:\n    m = re.search(r\"(\\w+)@(\\w+)\", text)\n    if m:\n        return m.group(1)\n    return \"\"\n");
    }

    #[test]
    fn test_w6_regex_group_no_args() {
        let _ok = transpile_ok("import re\ndef f(text: str) -> str:\n    m = re.search(\"abc\", text)\n    if m:\n        return m.group()\n    return \"\"\n");
    }

    // ========================================================================
    // SECTION 32: instance_dispatch.rs - deque methods
    // ========================================================================

    #[test]
    fn test_w6_deque_appendleft() {
        let _ok = transpile_ok("from collections import deque\ndef f() -> list:\n    d = deque()\n    d.appendleft(1)\n    return list(d)\n");
    }

    #[test]
    fn test_w6_deque_popleft() {
        let _ok = transpile_ok("from collections import deque\ndef f() -> int:\n    d = deque([1, 2, 3])\n    return d.popleft()\n");
    }

    #[test]
    fn test_w6_deque_extendleft() {
        let _ok = transpile_ok("from collections import deque\ndef f() -> list:\n    d = deque()\n    d.extendleft([1, 2, 3])\n    return list(d)\n");
    }

    #[test]
    fn test_w6_deque_append() {
        let _ok = transpile_ok("from collections import deque\ndef f() -> list:\n    d = deque()\n    d.append(1)\n    return list(d)\n");
    }

    // ========================================================================
    // SECTION 33: instance_dispatch.rs - dict on self fields
    // ========================================================================

    #[test]
    fn test_w6_self_dict_items() {
        let _ok = transpile_ok("class Config:\n    def __init__(self) -> None:\n        self.config = {\"a\": 1}\n    def get_items(self) -> list:\n        result = []\n        for k, v in self.config.items():\n            result.append(k)\n        return result\n");
    }

    #[test]
    fn test_w6_self_dict_keys() {
        let _ok = transpile_ok("class Config:\n    def __init__(self) -> None:\n        self.settings = {\"a\": 1}\n    def get_keys(self) -> list:\n        return list(self.settings.keys())\n");
    }

    #[test]
    fn test_w6_self_dict_values() {
        let _ok = transpile_ok("class Config:\n    def __init__(self) -> None:\n        self.data = {\"a\": 1}\n    def get_values(self) -> list:\n        return list(self.data.values())\n");
    }

    #[test]
    fn test_w6_self_dict_get() {
        let _ok = transpile_ok("class Config:\n    def __init__(self) -> None:\n        self.metadata = {\"key\": \"value\"}\n    def get_val(self, k: str) -> str:\n        return self.metadata.get(k, \"\")\n");
    }

    // ========================================================================
    // SECTION 34: dict_constructors.rs - dict literal
    // ========================================================================

    #[test]
    fn test_w6_dict_literal_string_keys() {
        let result = transpile("def f() -> dict:\n    return {\"a\": 1, \"b\": 2}\n");
        assert!(!result.is_empty());
        assert!(result.contains("HashMap") || result.contains("hash_map") || result.contains("insert"));
    }

    #[test]
    fn test_w6_dict_literal_int_values() {
        let result = transpile("def f() -> dict:\n    return {\"x\": 10, \"y\": 20}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_literal_string_values() {
        let result = transpile("def f() -> dict:\n    return {\"name\": \"alice\", \"role\": \"admin\"}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_literal_bool_values() {
        let result = transpile("def f() -> dict:\n    return {\"debug\": True, \"verbose\": False}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_literal_float_values() {
        let result = transpile("def f() -> dict:\n    return {\"pi\": 3.14, \"e\": 2.72}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_literal_empty() {
        let result = transpile("def f() -> dict:\n    return {}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_literal_single_entry() {
        let result = transpile("def f() -> dict:\n    return {\"key\": \"value\"}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_literal_many_entries() {
        let result = transpile("def f() -> dict:\n    return {\"a\": 1, \"b\": 2, \"c\": 3, \"d\": 4, \"e\": 5}\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 35: dict_constructors.rs - dict comprehension
    // ========================================================================

    #[test]
    fn test_w6_dict_comprehension_basic() {
        let result = transpile("def f(lst: list) -> dict:\n    return {x: x * 2 for x in lst}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_comprehension_with_condition() {
        let result = transpile("def f(lst: list) -> dict:\n    return {x: x * 2 for x in lst if x > 0}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_comprehension_string_keys() {
        let result = transpile("def f(words: list) -> dict:\n    return {w: len(w) for w in words}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_comprehension_enumerate() {
        let result = transpile("def f(lst: list) -> dict:\n    return {i: v for i, v in enumerate(lst)}\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 36: dict_constructors.rs - mixed type dicts
    // ========================================================================

    #[test]
    fn test_w6_dict_mixed_int_str_values() {
        let result = transpile("def f() -> dict:\n    return {\"name\": \"alice\", \"age\": 30}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_mixed_int_bool_values() {
        let result = transpile("def f() -> dict:\n    return {\"count\": 5, \"active\": True}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_mixed_with_none() {
        let result = transpile("def f() -> dict:\n    return {\"value\": 42, \"error\": None}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_mixed_str_float() {
        let result = transpile("def f() -> dict:\n    return {\"name\": \"test\", \"score\": 95.5}\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 37: dict_constructors.rs - nested dicts
    // ========================================================================

    #[test]
    fn test_w6_dict_nested_simple() {
        let result = transpile("def f() -> dict:\n    return {\"inner\": {\"a\": 1}}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_nested_double() {
        let result = transpile("def f() -> dict:\n    return {\"level1\": {\"level2\": {\"value\": 42}}}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_nested_with_list() {
        let result = transpile("def f() -> dict:\n    return {\"items\": [1, 2, 3]}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_nested_list_of_dicts() {
        let result = transpile("def f() -> dict:\n    return {\"records\": [{\"id\": 1}, {\"id\": 2}]}\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 38: dict_constructors.rs - from_keys
    // ========================================================================

    #[test]
    fn test_w6_dict_from_keys() {
        let _ok = transpile_ok("def f() -> dict:\n    keys = [\"a\", \"b\", \"c\"]\n    return dict.fromkeys(keys, 0)\n");
    }

    #[test]
    fn test_w6_dict_from_keys_none() {
        let _ok = transpile_ok("def f() -> dict:\n    keys = [\"a\", \"b\"]\n    return dict.fromkeys(keys)\n");
    }

    // ========================================================================
    // SECTION 39: Additional type_helpers.rs edge cases
    // ========================================================================

    #[test]
    fn test_w6_is_string_index_literal_string() {
        let result = transpile("def f(d: dict) -> int:\n    return d[\"key\"]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_is_string_index_literal_int() {
        let result = transpile("def f(lst: list) -> int:\n    return lst[0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_var_name_config() {
        let result = transpile("def f(config: dict) -> int:\n    return config[\"key\"]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_var_name_map() {
        let result = transpile("def f() -> int:\n    name_map = {\"a\": 1}\n    return name_map[\"a\"]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_var_name_value() {
        let result = transpile("def f(value: dict) -> int:\n    return value[\"x\"]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_is_dict_value_access_index() {
        let result = transpile("def f(d: dict) -> str:\n    return d[\"hash\"]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_is_dict_value_access_get_chain() {
        let result = transpile("def f(d: dict) -> str:\n    return d.get(\"name\", \"\")\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 40: Additional lambda_generators.rs edge cases
    // ========================================================================

    #[test]
    fn test_w6_lambda_body_binary() {
        let result = transpile("def f() -> int:\n    fn = lambda a, b: a * b + 1\n    return fn(3, 4)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_body_method_call() {
        let result = transpile("def f() -> str:\n    fn = lambda s: s.upper()\n    return fn(\"hi\")\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_body_comparison() {
        let result = transpile("def f() -> bool:\n    fn = lambda x: x > 0\n    return fn(5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_body_index() {
        let result = transpile("def f() -> int:\n    fn = lambda lst: lst[0]\n    return fn([1, 2, 3])\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_body_call() {
        let result = transpile("def f() -> int:\n    fn = lambda x: abs(x)\n    return fn(-5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_body_attr() {
        let _ok = transpile_ok("def f():\n    fn = lambda obj: obj.value\n    return fn\n");
    }

    #[test]
    fn test_w6_lambda_substitute_nested() {
        let result = transpile("def f() -> int:\n    items = [1, 2, 3]\n    fn = lambda x: items[x] + items[0]\n    return fn(1)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_substitute_in_tuple() {
        let result = transpile("def f() -> tuple:\n    offset = 10\n    fn = lambda x: (x, x + offset)\n    return fn(5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_substitute_in_set() {
        let _ok = transpile_ok("def f():\n    base = 0\n    fn = lambda x: {x, base}\n    return fn(1)\n");
    }

    #[test]
    fn test_w6_lambda_substitute_in_dict() {
        let _ok = transpile_ok("def f():\n    key = \"name\"\n    fn = lambda v: {key: v}\n    return fn(\"alice\")\n");
    }

    #[test]
    fn test_w6_lambda_nested_lambda_shadow() {
        let result = transpile("def f() -> int:\n    fn = lambda x: (lambda x: x + 1)(x)\n    return fn(5)\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 41: Additional method_call_routing.rs edge cases
    // ========================================================================

    #[test]
    fn test_w6_dynamic_call() {
        let _ok = transpile_ok("def f(fn, x: int) -> int:\n    return fn(x)\n");
    }

    #[test]
    fn test_w6_dynamic_call_no_args() {
        let _ok = transpile_ok("def f(fn) -> int:\n    return fn()\n");
    }

    #[test]
    fn test_w6_sys_stdin_read() {
        let _ok = transpile_ok("import sys\ndef f() -> str:\n    data = sys.stdin.read()\n    return data\n");
    }

    #[test]
    fn test_w6_sys_stdout_write() {
        let _ok = transpile_ok("import sys\ndef f() -> None:\n    sys.stdout.write(\"hello\")\n");
    }

    #[test]
    fn test_w6_sys_stderr_write() {
        let _ok = transpile_ok("import sys\ndef f() -> None:\n    sys.stderr.write(\"error\")\n");
    }

    // ========================================================================
    // SECTION 42: Additional instance_dispatch.rs - parse_args, add_argument
    // ========================================================================

    #[test]
    fn test_w6_argparse_parse_args() {
        let _ok = transpile_ok("import argparse\ndef main() -> None:\n    parser = argparse.ArgumentParser()\n    args = parser.parse_args()\n");
    }

    #[test]
    fn test_w6_argparse_add_argument() {
        let _ok = transpile_ok("import argparse\ndef main() -> None:\n    parser = argparse.ArgumentParser()\n    parser.add_argument(\"--name\", type=str)\n");
    }

    #[test]
    fn test_w6_argparse_print_help() {
        let _ok = transpile_ok("import argparse\ndef main() -> None:\n    parser = argparse.ArgumentParser()\n    parser.print_help()\n");
    }

    // ========================================================================
    // SECTION 43: Additional instance_dispatch.rs - class instance methods
    // ========================================================================

    #[test]
    fn test_w6_class_method_call() {
        let result = transpile("class Dog:\n    def __init__(self, name: str) -> None:\n        self.name = name\n    def bark(self) -> str:\n        return f\"{self.name} says woof\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_class_method_with_arg() {
        let result = transpile("class Counter:\n    def __init__(self, count: int) -> None:\n        self.count = count\n    def add(self, n: int) -> int:\n        self.count = self.count + n\n        return self.count\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_class_method_with_string_literal() {
        let _ok = transpile_ok("class Greeter:\n    def __init__(self) -> None:\n        self.prefix = \"Hello\"\n    def greet(self, name: str) -> str:\n        return f\"{self.prefix} {name}\"\n");
    }

    // ========================================================================
    // SECTION 44: Additional dict_constructors.rs - non-string keys
    // ========================================================================

    #[test]
    fn test_w6_dict_int_keys() {
        let result = transpile("def f() -> dict:\n    return {1: \"a\", 2: \"b\"}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_bool_keys() {
        let result = transpile("def f() -> dict:\n    return {True: 1, False: 0}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_tuple_value() {
        let result = transpile("def f() -> dict:\n    return {\"pos\": (1, 2), \"size\": (10, 20)}\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 45: method_call_routing.rs - subprocess child wait
    // ========================================================================

    #[test]
    fn test_w6_subprocess_wait() {
        let _ok = transpile_ok("import subprocess\ndef f() -> int:\n    proc = subprocess.Popen([\"ls\"])\n    return proc.wait()\n");
    }

    // ========================================================================
    // SECTION 46: Additional coverage for type_helpers - is_json_value_iteration
    // ========================================================================

    #[test]
    fn test_w6_json_loads_iteration() {
        let _ok = transpile_ok("import json\ndef f(text: str) -> list:\n    data = json.loads(text)\n    result = []\n    for item in data:\n        result.append(item)\n    return result\n");
    }

    #[test]
    fn test_w6_json_dict_index_iteration() {
        let _ok = transpile_ok("import json\ndef f(text: str) -> list:\n    data = json.loads(text)\n    result = []\n    for k in data:\n        result.append(k)\n    return result\n");
    }

    // ========================================================================
    // SECTION 47: Additional coverage for is_numpy_array_expr
    // ========================================================================

    #[test]
    fn test_w6_numpy_zeros() {
        let _ok = transpile_ok("import numpy as np\ndef f(n: int):\n    arr = np.zeros(n)\n    return arr\n");
    }

    #[test]
    fn test_w6_numpy_ones() {
        let _ok = transpile_ok("import numpy as np\ndef f(n: int):\n    arr = np.ones(n)\n    return arr\n");
    }

    #[test]
    fn test_w6_numpy_array() {
        let _ok = transpile_ok("import numpy as np\ndef f():\n    arr = np.array([1, 2, 3])\n    return arr\n");
    }

    // ========================================================================
    // SECTION 48: Additional coverage for string_base heuristics
    // ========================================================================

    #[test]
    fn test_w6_string_base_var_separator() {
        let result = transpile("def f(separator: str, parts: list) -> str:\n    return separator.join(parts)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_var_char() {
        let result = transpile("def f(char: str) -> bool:\n    return char.isalpha()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_suffix_str() {
        let result = transpile("def f(input_str: str) -> str:\n    return input_str.upper()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_suffix_string() {
        let result = transpile("def f(input_string: str) -> str:\n    return input_string.lower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_base_suffix_text() {
        let result = transpile("def f(body_text: str) -> str:\n    return body_text.strip()\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 49: Additional list comprehensions + set comprehensions
    // ========================================================================

    #[test]
    fn test_w6_list_comprehension_simple() {
        let result = transpile("def f(lst: list) -> list:\n    return [x * 2 for x in lst]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_list_comprehension_filter() {
        let result = transpile("def f(lst: list) -> list:\n    return [x for x in lst if x > 0]\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_comprehension() {
        let result = transpile("def f(lst: list) -> set:\n    return {x * 2 for x in lst}\n");
        assert!(!result.is_empty());
    }

    // ========================================================================
    // SECTION 50: Additional edge cases for higher coverage
    // ========================================================================

    #[test]
    fn test_w6_string_capitalize() {
        let result = transpile("def f(s: str) -> str:\n    return s.capitalize()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_swapcase() {
        let result = transpile("def f(s: str) -> str:\n    return s.swapcase()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_isupper() {
        let result = transpile("def f(s: str) -> bool:\n    return s.isupper()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_islower() {
        let result = transpile("def f(s: str) -> bool:\n    return s.islower()\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_string_rindex() {
        let _ok = transpile_ok("def f(s: str) -> int:\n    return s.rindex(\"x\")\n");
    }

    #[test]
    fn test_w6_string_hex_method() {
        let _ok = transpile_ok("def f(s: str) -> str:\n    return s.hex()\n");
    }

    #[test]
    fn test_w6_dict_typed_annotation() {
        let result = transpile("from typing import Dict\ndef f() -> Dict[str, int]:\n    return {\"a\": 1}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_typed_float_annotation() {
        let result = transpile("from typing import Dict\ndef f() -> Dict[str, float]:\n    return {\"pi\": 3.14, \"count\": 5}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_as_sorted_key_complex() {
        let result = transpile("def f(pairs: list) -> list:\n    return sorted(pairs, key=lambda p: p[1])\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_lambda_with_unary() {
        let result = transpile("def f() -> int:\n    fn = lambda x: -x\n    return fn(5)\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_concat_multiple() {
        let result = transpile("def f(a: str, b: int, c: float) -> str:\n    return f\"{a}: {b} ({c})\"\n");
        assert!(!result.is_empty());
        assert!(result.contains("format!"));
    }

    #[test]
    fn test_w6_ternary_same_test_and_body() {
        let result = transpile("def f(x: int) -> int:\n    return x if x else 0\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_in_ternary_string() {
        let result = transpile("def f(s: str) -> str:\n    return s if s else \"default\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_in_ternary_list() {
        let result = transpile("def f(lst: list) -> list:\n    return lst if lst else []\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_truthiness_in_ternary_dict() {
        let result = transpile("def f(d: dict) -> dict:\n    return d if d else {}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_assign_typed() {
        let result = transpile("from typing import Dict, Any\ndef f() -> Dict[str, Any]:\n    data: dict = {\"name\": \"test\", \"count\": 42}\n    return data\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_return_typed_any() {
        let result = transpile("from typing import Dict, Any\ndef f() -> Dict[str, Any]:\n    return {\"key\": \"val\", \"num\": 1}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_nested_with_mixed() {
        let result = transpile("def f() -> dict:\n    return {\"meta\": {\"name\": \"test\", \"count\": 5}}\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_path_div_operator() {
        let _ok = transpile_ok("from pathlib import Path\ndef f() -> str:\n    base = Path(\"/tmp\")\n    full = base / \"subdir\" / \"file.txt\"\n    return str(full)\n");
    }

    #[test]
    fn test_w6_frozenset_expr() {
        let result = transpile("def f() -> frozenset:\n    return frozenset({1, 2, 3})\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_set_update() {
        let result = transpile("def f(a: set, b: set) -> set:\n    a.update(b)\n    return a\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_clone_then_method() {
        let result = transpile("def f(d: dict) -> list:\n    d2 = d.copy()\n    return list(d2.keys())\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_dict_var() {
        let result = transpile("def f(d: dict) -> str:\n    return f\"Dict: {d}\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_optional_var() {
        let result = transpile("from typing import Optional\ndef f(x: Optional[int]) -> str:\n    return f\"Value: {x}\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_fstring_with_list_method_split() {
        let result = transpile("def f(s: str) -> str:\n    parts = s.split(\",\")\n    return f\"Parts: {parts}\"\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_named_expr_walrus() {
        let _ok = transpile_ok("def f(lst: list) -> int:\n    if (n := len(lst)) > 0:\n        return n\n    return 0\n");
    }

    #[test]
    fn test_w6_enumerate_loop() {
        let result = transpile("def f(lst: list) -> list:\n    result = []\n    for i, v in enumerate(lst):\n        result.append(i)\n    return result\n");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_w6_dict_items_loop() {
        let result = transpile("def f(d: dict) -> list:\n    result = []\n    for k, v in d.items():\n        result.append(k)\n    return result\n");
        assert!(!result.is_empty());
    }
}