java2pyi 2.0.1

Java class files to Python stubs for mypy/pyright
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::{collections::HashSet, sync::Arc};

use crate::{
    ir,
    model::{ClassRef, Root},
};

#[derive(Debug, Default, Clone)]
pub struct Exclusions<'a> {
    excluded: HashSet<ClassRef<'a>>,
}

impl<'a> Exclusions<'a> {
    pub fn insert(&mut self, value: ClassRef<'a>) {
        self.excluded.insert(value);
    }

    pub fn contains(&self, value: ClassRef<'a>) -> bool {
        self.excluded.contains(&value)
    }
}

pub fn retain(
    roots: &mut Vec<Arc<Root>>,
    exclude_packages: &[String],
    exclude_identifiers: &HashSet<String>,
) {
    if exclude_packages.is_empty() && exclude_identifiers.is_empty() {
        return;
    }

    roots.retain(|root| {
        let ir = root.ir();

        !is_excluded_package(ir.package, exclude_packages)
            && ir
                .classes
                .iter()
                .any(|class| !exclude_identifiers.contains(&qualify(ir.package, class.name)))
    });
}

pub fn collect<'a>(
    roots: &'a [Arc<Root>],
    exclude_identifiers: &HashSet<String>,
) -> Exclusions<'a> {
    let mut exclusions = Exclusions::default();
    if exclude_identifiers.is_empty() {
        return exclusions;
    }

    for root in roots {
        let ir = root.ir();
        collect_into(ir.classes, ir.package, exclude_identifiers, &mut exclusions);
    }

    exclusions
}

fn is_excluded_package(package: &str, exclude_packages: &[String]) -> bool {
    exclude_packages.iter().any(|prefix| {
        package == prefix
            || package
                .strip_prefix(prefix)
                .is_some_and(|suffix| suffix.starts_with('.'))
    })
}

fn qualify(prefix: &str, name: &str) -> String {
    if prefix.is_empty() {
        name.to_string()
    } else {
        format!("{}.{}", prefix, name)
    }
}

fn collect_into<'a>(
    classes: &'a [ir::Class<'a>],
    prefix: &str,
    exclude_identifiers: &HashSet<String>,
    exclusions: &mut Exclusions<'a>,
) {
    for class in classes {
        let path = qualify(prefix, class.name);

        if exclude_identifiers.contains(&path) {
            exclusions.insert(ClassRef::new(class));
            continue;
        }

        collect_into(class.children, &path, exclude_identifiers, exclusions);
    }
}