forked from M-Labs/nac3
110 lines
3.4 KiB
Rust
110 lines
3.4 KiB
Rust
use super::super::typedef::*;
|
|
use std::collections::HashMap;
|
|
use std::rc::Rc;
|
|
|
|
/// Structure for storing top-level type definitions.
|
|
/// Used for collecting type signature from source code.
|
|
/// Can be converted to `InferenceContext` for type inference in functions.
|
|
pub struct GlobalContext<'a> {
|
|
/// List of primitive definitions.
|
|
pub(super) primitive_defs: Vec<TypeDef<'a>>,
|
|
/// List of class definitions.
|
|
pub(super) class_defs: Vec<ClassDef<'a>>,
|
|
/// List of parametric type definitions.
|
|
pub(super) parametric_defs: Vec<ParametricDef<'a>>,
|
|
/// List of type variable definitions.
|
|
pub(super) var_defs: Vec<VarDef<'a>>,
|
|
/// Function name to signature mapping.
|
|
pub(super) fn_table: HashMap<&'a str, FnDef>,
|
|
|
|
primitives: Vec<Type>,
|
|
variables: Vec<Type>,
|
|
}
|
|
|
|
impl<'a> GlobalContext<'a> {
|
|
pub fn new(primitive_defs: Vec<TypeDef<'a>>) -> GlobalContext {
|
|
let mut primitives = Vec::new();
|
|
for (i, t) in primitive_defs.iter().enumerate() {
|
|
primitives.push(TypeEnum::PrimitiveType(PrimitiveId(i)).into());
|
|
}
|
|
GlobalContext {
|
|
primitive_defs,
|
|
class_defs: Vec::new(),
|
|
parametric_defs: Vec::new(),
|
|
var_defs: Vec::new(),
|
|
fn_table: HashMap::new(),
|
|
primitives,
|
|
variables: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn add_class(&mut self, def: ClassDef<'a>) -> ClassId {
|
|
self.class_defs.push(def);
|
|
ClassId(self.class_defs.len() - 1)
|
|
}
|
|
|
|
pub fn add_parametric(&mut self, def: ParametricDef<'a>) -> ParamId {
|
|
self.parametric_defs.push(def);
|
|
ParamId(self.parametric_defs.len() - 1)
|
|
}
|
|
|
|
pub fn add_variable(&mut self, def: VarDef<'a>) -> VariableId {
|
|
self.add_variable_private(def)
|
|
}
|
|
|
|
pub fn add_variable_private(&mut self, def: VarDef<'a>) -> VariableId {
|
|
self.var_defs.push(def);
|
|
self.variables
|
|
.push(TypeEnum::TypeVariable(VariableId(self.var_defs.len() - 1)).into());
|
|
VariableId(self.var_defs.len() - 1)
|
|
}
|
|
|
|
pub fn add_fn(&mut self, name: &'a str, def: FnDef) {
|
|
self.fn_table.insert(name, def);
|
|
}
|
|
|
|
pub fn get_fn_def(&self, name: &str) -> Option<&FnDef> {
|
|
self.fn_table.get(name)
|
|
}
|
|
|
|
pub fn get_primitive_def_mut(&mut self, id: PrimitiveId) -> &mut TypeDef<'a> {
|
|
self.primitive_defs.get_mut(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_primitive_def(&self, id: PrimitiveId) -> &TypeDef {
|
|
self.primitive_defs.get(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_class_def_mut(&mut self, id: ClassId) -> &mut ClassDef<'a> {
|
|
self.class_defs.get_mut(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_class_def(&self, id: ClassId) -> &ClassDef {
|
|
self.class_defs.get(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_parametric_def_mut(&mut self, id: ParamId) -> &mut ParametricDef<'a> {
|
|
self.parametric_defs.get_mut(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_parametric_def(&self, id: ParamId) -> &ParametricDef {
|
|
self.parametric_defs.get(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_variable_def_mut(&mut self, id: VariableId) -> &mut VarDef<'a> {
|
|
self.var_defs.get_mut(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_variable_def(&self, id: VariableId) -> &VarDef {
|
|
self.var_defs.get(id.0).unwrap()
|
|
}
|
|
|
|
pub fn get_primitive(&self, id: PrimitiveId) -> Type {
|
|
self.primitives.get(id.0).unwrap().clone()
|
|
}
|
|
|
|
pub fn get_variable(&self, id: VariableId) -> Type {
|
|
self.variables.get(id.0).unwrap().clone()
|
|
}
|
|
}
|