Use LinkedList in scope locals

Author: palaviv

vm/src/scope.rs

@@ -1,5 +1,5 @@
+use std::collections::LinkedList;
 use std::fmt;
-use std::rc::Rc;
 
 use crate::obj::objdict::PyDictRef;
 use crate::pyobject::{ItemProtocol, PyContext, PyObjectRef, PyResult};
@@ -9,58 +9,9 @@ use crate::vm::VirtualMachine;
  * So a scope is a linked list of scopes.
  * When a name is looked up, it is check in its scope.
  */
-#[derive(Debug)]
-struct RcListNode<T> {
-    elem: T,
-    next: Option<Rc<RcListNode<T>>>,
-}
-
-#[derive(Debug, Clone)]
-struct RcList<T> {
-    head: Option<Rc<RcListNode<T>>>,
-}
-
-struct Iter<'a, T: 'a> {
-    next: Option<&'a RcListNode<T>>,
-}
-
-impl<T> RcList<T> {
-    pub fn new() -> Self {
-        RcList { head: None }
-    }
-
-    pub fn insert(self, elem: T) -> Self {
-        RcList {
-            head: Some(Rc::new(RcListNode {
-                elem,
-                next: self.head,
-            })),
-        }
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("RcList"))]
-    pub fn iter(&self) -> Iter<T> {
-        Iter {
-            next: self.head.as_ref().map(|node| &**node),
-        }
-    }
-}
-
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = &'a T;
-
-    #[cfg_attr(feature = "flame-it", flame("Iter"))]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.next.map(|node| {
-            self.next = node.next.as_ref().map(|node| &**node);
-            &node.elem
-        })
-    }
-}
-
 #[derive(Clone)]
 pub struct Scope {
-    locals: RcList<PyDictRef>,
+    locals: LinkedList<PyDictRef>,
     pub globals: PyDictRef,
 }
 
@@ -73,11 +24,14 @@ impl fmt::Debug for Scope {
 
 impl Scope {
     pub fn new(locals: Option<PyDictRef>, globals: PyDictRef, vm: &VirtualMachine) -> Scope {
-        let locals = match locals {
-            Some(dict) => RcList::new().insert(dict),
-            None => RcList::new(),
+        let mut locals_list = LinkedList::new();
+        if let Some(dict) = locals {
+            locals_list.push_front(dict)
+        }
+        let scope = Scope {
+            locals: locals_list,
+            globals,
         };
-        let scope = Scope { locals, globals };
         scope.store_name(vm, "__annotations__", vm.ctx.new_dict().into_object());
         scope
     }
@@ -97,19 +51,21 @@ impl Scope {
     }
 
     pub fn get_locals(&self) -> PyDictRef {
-        match self.locals.iter().next() {
+        match self.locals.front() {
             Some(dict) => dict.clone(),
             None => self.globals.clone(),
         }
     }
 
     pub fn get_only_locals(&self) -> Option<PyDictRef> {
-        self.locals.iter().next().cloned()
+        self.locals.front().cloned()
     }
 
     pub fn new_child_scope_with_locals(&self, locals: PyDictRef) -> Scope {
+        let mut new_locals = self.locals.clone();
+        new_locals.push_front(locals);
         Scope {
-            locals: self.locals.clone().insert(locals),
+            locals: new_locals,
             globals: self.globals.clone(),
         }
     }