[pypy-commit] lang-smalltalk storage: Fixed RPython compile error regarding constructors. Reduced code duplication.

[anton_gulenko]

Author: Anton Gulenko <anton.gulenko at googlemail.com>
Branch: storage
Changeset: r728:6558ff7c5237
Date: 2014-03-31 15:31 +0200
http://bitbucket.org/pypy/lang-smalltalk/changeset/6558ff7c5237/

Log:	Fixed RPython compile error regarding constructors. Reduced code
	duplication.

diff --git a/spyvm/model.py b/spyvm/model.py
--- a/spyvm/model.py
+++ b/spyvm/model.py
@@ -559,7 +559,8 @@
     
     def initialize_storage(self, space, size, weak=False):
         from spyvm.shadow import empty_storage
-        self.store_shadow(empty_storage(space, size, weak)(space, self, size))
+        storage = empty_storage(space, self, size, weak)
+        self.store_shadow(storage)
         self.log_storage("Initialized")
     
     def fillin(self, space, g_self):
diff --git a/spyvm/shadow.py b/spyvm/shadow.py
--- a/spyvm/shadow.py
+++ b/spyvm/shadow.py
@@ -56,6 +56,8 @@
 class AbstractStorageShadow(AbstractShadow):
     _attrs_ = []
     repr_classname = "AbstractStorageShadow"
+    def __init__(self, space, w_self, size):
+        AbstractShadow.__init__(self, space, w_self)
     def store(self, n0, w_val):
         if self.can_contain(w_val):
             return self.do_store(n0, w_val)
@@ -73,7 +75,7 @@
     _attrs_ = ['_size']
     _immutable_fields_ = ['_size']
     def __init__(self, space, w_self, size):
-        AbstractShadow.__init__(self, space, w_self)
+        AbstractStorageShadow.__init__(self, space, w_self, size)
         self._size = size
     def fetch(self, n0):
         if n0 >= self._size:
@@ -95,7 +97,7 @@
     _immutable_fields_ = ['storage']
     
     def __init__(self, space, w_self, size):
-        AbstractStorageShadow.__init__(self, space, w_self)
+        AbstractStorageShadow.__init__(self, space, w_self, size)
         self.storage = [self.nil_value] * size
     
     def size(self):
@@ -162,14 +164,14 @@
     def unwrap(space, w_val):
         return space.unwrap_float(w_val)
 
-def empty_storage(space, size, weak=False):
+def empty_storage(space, w_self, size, weak=False):
     if weak:
-        return WeakListStorageShadow
+        return WeakListStorageShadow(space, w_self, size)
     else:
         if no_specialized_storage:
-            return ListStorageShadow
+            return ListStorageShadow(space, w_self, size)
         else:
-            return AllNilStorageShadow
+            return AllNilStorageShadow(space, w_self, size)
 
 def find_storage_for_objects(space, vars):
     if no_specialized_storage:
@@ -201,15 +203,23 @@
     
     # If this happens, please look for a bug in the code above.
     assert False, "No strategy could be found for list..."
-    
-class ListStorageShadow(AbstractShadow):
+
+class ListStorageMixin(object):
+    def __init__(self, space, w_self, size):
+        AbstractStorageShadow.__init__(self, space, w_self, size)
+        self.initialize_storage(size)
+    def size(self):
+        return len(self.storage)
+    def copy_from(self, other_shadow):
+        if self.size() != other_shadow.size():
+            self.initialize_storage(other_shadow.size())
+        AbstractShadow.copy_from(self, other_shadow)
+
+class ListStorageShadow(AbstractStorageShadow):
     _attrs_ = ['storage']
     _immutable_fields_ = ['storage']
     repr_classname = "ListStorageShadow"
-    
-    def __init__(self, space, w_self, size):
-        AbstractShadow.__init__(self, space, w_self)
-        self.initialize_storage(size)
+    import_from_mixin(ListStorageMixin)
     
     def initialize_storage(self, size):
         self.storage = [self.space.w_nil] * size
@@ -217,30 +227,21 @@
         return self.storage[n0]
     def store(self, n0, w_value):
         self.storage[n0] = w_value
-    def size(self):
-        return len(self.storage)
-    def copy_from(self, other_shadow):
-        if self.size() != other_shadow.size():
-            self.initialize_storage(other_shadow.size())
-        AbstractShadow.copy_from(self, other_shadow)
 
-class WeakListStorageShadow(AbstractShadow):
+class WeakListStorageShadow(AbstractStorageShadow):
     _attrs_ = ['storage']
     _immutable_fields_ = ['storage']
     repr_classname = "WeakListStorageShadow"
+    import_from_mixin(ListStorageMixin)
     
-    def __init__(self, space, w_self, size):
-        AbstractShadow.__init__(self, space, w_self)
-        self.storage = [weakref.ref(space.w_nil)] * size
-    
+    def initialize_storage(self, size):
+        self.storage = [weakref.ref(self.space.w_nil)] * size
     def fetch(self, n0):
         weakobj = self.storage[n0]
         return weakobj() or self.space.w_nil
     def store(self, n0, w_value):
         assert w_value is not None
         self.storage[n0] = weakref.ref(w_value)
-    def size(self):
-        return len(self.storage)
     
 class AbstractCachingShadow(ListStorageShadow):
     _immutable_fields_ = ['version?']