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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
use crate::{builtins::PyDictRef, function::ArgMapping, VirtualMachine};
use std::fmt;
#[derive(Clone)]
pub struct Scope {
pub locals: ArgMapping,
pub globals: PyDictRef,
}
impl fmt::Debug for Scope {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// TODO: have a more informative Debug impl that DOESN'T recurse and cause a stack overflow
f.write_str("Scope")
}
}
impl Scope {
#[inline]
pub fn new(locals: Option<ArgMapping>, globals: PyDictRef) -> Scope {
let locals = locals.unwrap_or_else(|| ArgMapping::from_dict_exact(globals.clone()));
Scope { locals, globals }
}
pub fn with_builtins(
locals: Option<ArgMapping>,
globals: PyDictRef,
vm: &VirtualMachine,
) -> Scope {
if !globals.contains_key("__builtins__", vm) {
globals
.set_item("__builtins__", vm.builtins.clone().into(), vm)
.unwrap();
}
Scope::new(locals, globals)
}
// pub fn get_locals(&self) -> &PyDictRef {
// match self.locals.first() {
// Some(dict) => dict,
// None => &self.globals,
// }
// }
// pub fn get_only_locals(&self) -> Option<PyDictRef> {
// self.locals.first().cloned()
// }
// pub fn new_child_scope_with_locals(&self, locals: PyDictRef) -> Scope {
// let mut new_locals = Vec::with_capacity(self.locals.len() + 1);
// new_locals.push(locals);
// new_locals.extend_from_slice(&self.locals);
// Scope {
// locals: new_locals,
// globals: self.globals.clone(),
// }
// }
// pub fn new_child_scope(&self, ctx: &Context) -> Scope {
// self.new_child_scope_with_locals(ctx.new_dict())
// }
// #[cfg_attr(feature = "flame-it", flame("Scope"))]
// pub fn load_name(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
// for dict in self.locals.iter() {
// if let Some(value) = dict.get_item_option(name.clone(), vm).unwrap() {
// return Some(value);
// }
// }
// // Fall back to loading a global after all scopes have been searched!
// self.load_global(vm, name)
// }
// #[cfg_attr(feature = "flame-it", flame("Scope"))]
// /// Load a local name. Only check the local dictionary for the given name.
// pub fn load_local(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
// self.get_locals().get_item_option(name, vm).unwrap()
// }
// #[cfg_attr(feature = "flame-it", flame("Scope"))]
// pub fn load_cell(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
// for dict in self.locals.iter().skip(1) {
// if let Some(value) = dict.get_item_option(name.clone(), vm).unwrap() {
// return Some(value);
// }
// }
// None
// }
// pub fn store_cell(&self, vm: &VirtualMachine, name: impl PyName, value: PyObjectRef) {
// // find the innermost outer scope that contains the symbol name
// if let Some(locals) = self
// .locals
// .iter()
// .rev()
// .find(|l| l.contains_key(name.clone(), vm))
// {
// // add to the symbol
// locals.set_item(name, value, vm).unwrap();
// } else {
// // somewhat limited solution -> fallback to the old rustpython strategy
// // and store the next outer scope
// // This case is usually considered as a failure case, but kept for the moment
// // to support the scope propagation for named expression assignments to so far
// // unknown names in comprehensions. We need to consider here more context
// // information for correct handling.
// self.locals
// .get(1)
// .expect("no outer scope for non-local")
// .set_item(name, value, vm)
// .unwrap();
// }
// }
// pub fn store_name(&self, vm: &VirtualMachine, key: impl PyName, value: PyObjectRef) {
// self.get_locals().set_item(key, value, vm).unwrap();
// }
// pub fn delete_name(&self, vm: &VirtualMachine, key: impl PyName) -> PyResult {
// self.get_locals().del_item(key, vm)
// }
// #[cfg_attr(feature = "flame-it", flame("Scope"))]
// /// Load a global name.
// pub fn load_global(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
// if let Some(value) = self.globals.get_item_option(name.clone(), vm).unwrap() {
// Some(value)
// } else {
// vm.builtins.get_attr(name, vm).ok()
// }
// }
// pub fn store_global(&self, vm: &VirtualMachine, name: impl PyName, value: PyObjectRef) {
// self.globals.set_item(name, value, vm).unwrap();
// }
}
// mod sealed {
// pub trait Sealed {}
// impl Sealed for &str {}
// impl Sealed for super::PyStrRef {}
// }
// pub trait PyName:
// sealed::Sealed + crate::dictdatatype::DictKey + Clone + ToPyObject
// {
// }
// impl PyName for str {}
// impl PyName for Py<PyStr> {}