py_declare/
defs.rs

1use crate::*;
2use py_ir::types::TypeDefine;
3
4use std::collections::HashMap;
5use terl::Span;
6
7#[derive(Default)]
8pub struct Defs {
9    pub(crate) fn_signs: FnSigns,
10}
11
12impl Defs {
13    pub fn new() -> Self {
14        Self::default()
15    }
16
17    pub fn new_fn(&mut self, unmangled: &str, mangled: &str, sign: defs::FnSign) -> Type {
18        self.fn_signs.new_fn(unmangled, mangled, sign)
19    }
20
21    pub fn get_mangled(&self, name: &str) -> &Overload {
22        self.fn_signs.get_mangled(name)
23    }
24
25    pub fn try_get_mangled(&self, name: &str) -> Option<&Overload> {
26        self.fn_signs.try_get_mangled(name)
27    }
28
29    pub fn get_unmangled(&self, name: &str) -> Option<&[Overload]> {
30        self.fn_signs.get_unmangled(name)
31    }
32}
33
34#[derive(Default)]
35pub struct FnSigns {
36    fn_signs: Vec<Overload>,
37    unmangled: HashMap<String, Vec<Overload>>,
38    mangled: HashMap<String, Overload>,
39}
40
41impl FnSigns {
42    pub fn new() -> Self {
43        Self::default()
44    }
45
46    pub fn new_fn(&mut self, unmangled: &str, mangled: &str, sign: defs::FnSign) -> Type {
47        let value = defs::FnSignWithName {
48            sign,
49            name: mangled.to_owned(),
50        };
51
52        let overload: Overload = value.into();
53
54        self.fn_signs.push(overload.clone());
55        self.unmangled
56            .entry(unmangled.to_owned())
57            .or_default()
58            .push(overload.clone());
59        self.mangled.insert(mangled.to_owned(), overload.clone());
60        Type::Overload(overload)
61    }
62
63    pub fn get_unmangled(&self, name: &str) -> Option<&[Overload]> {
64        self.unmangled.get(name).map(|v| &**v)
65    }
66
67    pub fn get_mangled(&self, name: &str) -> &Overload {
68        self.mangled.get(name).unwrap()
69    }
70
71    pub fn try_get_mangled(&self, name: &str) -> Option<&Overload> {
72        self.mangled.get(name)
73    }
74
75    // pub fn search_fns
76}
77
78#[derive(Debug, Clone)]
79pub struct FnSignWithName {
80    pub sign: FnSign,
81    pub name: String,
82}
83
84impl std::ops::Deref for FnSignWithName {
85    type Target = FnSign;
86
87    fn deref(&self) -> &Self::Target {
88        &self.sign
89    }
90}
91
92impl std::ops::DerefMut for FnSignWithName {
93    fn deref_mut(&mut self) -> &mut Self::Target {
94        &mut self.sign
95    }
96}
97
98#[derive(Debug, Clone)]
99pub struct FnSign {
100    /// return type of the function must be cleared (will change in future versions)
101    pub ty: TypeDefine,
102    pub params: Vec<Parameter>,
103    pub retty_span: Span,
104    pub sign_span: Span,
105}
106
107impl FnSign {
108    pub fn new(ty: TypeDefine, params: Vec<Parameter>, retty_span: Span, sign_span: Span) -> Self {
109        Self {
110            ty,
111            params,
112            retty_span,
113            sign_span,
114        }
115    }
116}
117
118impl std::fmt::Display for FnSignWithName {
119    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
120        // NOTO: this may only work with default Chinese Mangler
121        let unmangled = self.name.split_ascii_whitespace().next().unwrap();
122        f.write_str(unmangled)?;
123        f.write_str("(")?;
124        match self.params.len() {
125            0 => f.write_str(")")?,
126            1 => f.write_fmt(format_args!("{})", self.params[0].ty))?,
127            _ => {
128                f.write_fmt(format_args!("{}", self.params[0].ty))?;
129                for param in &self.params[1..] {
130                    f.write_fmt(format_args!(", {}", param.name))?;
131                }
132                f.write_str(")")?
133            }
134        }
135        f.write_fmt(format_args!(" -> {}", self.ty))
136    }
137}
138
139pub type Parameter = py_ir::Parameter<TypeDefine>;
140
141#[derive(Debug, Clone)]
142pub struct VarDef {
143    pub ty: GroupIdx,
144    pub mutable: bool,
145}
py_declare/defs.rs

py_declare/
defs.rs
