rename super ambiguous "index" to "attrkind"

1 files changed, 70 insertions, 70 deletions

diff --git a/pypy/objspace/std/mapdict.py b/pypy/objspace/std/mapdict.py
index a83c67d791..9efe969a98 100644
--- a/pypy/objspace/std/mapdict.py
+++ b/pypy/objspace/std/mapdict.py
@@ -40,10 +40,10 @@ class AbstractAttribute(object):
         assert isinstance(terminator, Terminator)
         self.terminator = terminator
 
-    def read(self, obj, name, index):
-        attr = self.find_map_attr(name, index)
+    def read(self, obj, name, attrkind):
+        attr = self.find_map_attr(name, attrkind)
         if attr is None:
-            return self.terminator._read_terminator(obj, name, index)
+            return self.terminator._read_terminator(obj, name, attrkind)
         if (
             jit.isconstant(attr.storageindex) and
             jit.isconstant(obj) and
@@ -57,20 +57,20 @@ class AbstractAttribute(object):
     def _pure_mapdict_read_storage(self, obj, storageindex):
         return obj._mapdict_read_storage(storageindex)
 
-    def write(self, obj, name, index, w_value):
-        attr = self.find_map_attr(name, index)
+    def write(self, obj, name, attrkind, w_value):
+        attr = self.find_map_attr(name, attrkind)
         if attr is None:
-            return self.terminator._write_terminator(obj, name, index, w_value)
+            return self.terminator._write_terminator(obj, name, attrkind, w_value)
         if not attr.ever_mutated:
             attr.ever_mutated = True
         obj._mapdict_write_storage(attr.storageindex, w_value)
         return True
 
-    def delete(self, obj, name, index):
+    def delete(self, obj, name, attrkind):
         pass
 
     @jit.elidable
-    def find_map_attr(self, name, index):
+    def find_map_attr(self, name, attrkind):
         # attr cache
         space = self.space
         cache = space.fromcache(MapAttrCache)
@@ -84,7 +84,7 @@ class AbstractAttribute(object):
         c1 = 0x345678
         c2 = 1000003
         hash_name = objectmodel.compute_hash(name)
-        hash_selector = intmask((c2 * ((c2 * c1) ^ hash_name)) ^ index)
+        hash_selector = intmask((c2 * ((c2 * c1) ^ hash_name)) ^ attrkind)
         product = intmask(attrs_as_int * hash_selector)
         attr_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
         # ^^^Note2: same comment too
@@ -92,24 +92,24 @@ class AbstractAttribute(object):
         if cached_attr is self:
             cached_name = cache.names[attr_hash]
             cached_index = cache.indexes[attr_hash]
-            if cached_name == name and cached_index == index:
+            if cached_name == name and cached_index == attrkind:
                 attr = cache.cached_attrs[attr_hash]
                 if space.config.objspace.std.withmethodcachecounter:
                     cache.hits[name] = cache.hits.get(name, 0) + 1
                 return attr
-        attr = self._find_map_attr(name, index)
+        attr = self._find_map_attr(name, attrkind)
         if space._side_effects_ok():
             cache.attrs[attr_hash] = self
             cache.names[attr_hash] = name
-            cache.indexes[attr_hash] = index
+            cache.indexes[attr_hash] = attrkind
             cache.cached_attrs[attr_hash] = attr
             if space.config.objspace.std.withmethodcachecounter:
                 cache.misses[name] = cache.misses.get(name, 0) + 1
         return attr
 
-    def _find_map_attr(self, name, index):
+    def _find_map_attr(self, name, attrkind):
         while isinstance(self, PlainAttribute):
-            if index == self.index and name == self.name:
+            if attrkind == self.attrkind and name == self.name:
                 return self
             self = self.back
         return None
@@ -134,18 +134,18 @@ class AbstractAttribute(object):
         return None
 
     @jit.elidable
-    def _get_new_attr(self, name, index):
+    def _get_new_attr(self, name, attrkind):
         cache = self.cache_attrs
         if cache is None:
             cache = self.cache_attrs = {}
-        attr = cache.get((name, index), None)
+        attr = cache.get((name, attrkind), None)
         if attr is None:
-            attr = PlainAttribute(name, index, self)
-            cache[name, index] = attr
+            attr = PlainAttribute(name, attrkind, self)
+            cache[name, attrkind] = attr
         return attr
 
-    def add_attr(self, obj, name, index, w_value):
-        self._reorder_and_add(obj, name, index, w_value)
+    def add_attr(self, obj, name, attrkind, w_value):
+        self._reorder_and_add(obj, name, attrkind, w_value)
         if not jit.we_are_jitted():
             oldattr = self
             attr = obj._get_mapdict_map()
@@ -167,13 +167,13 @@ class AbstractAttribute(object):
 
 
     @jit.elidable
-    def _find_branch_to_move_into(self, name, index):
+    def _find_branch_to_move_into(self, name, attrkind):
         # walk up the map chain to find an ancestor with lower order that
         # already has the current name as a child inserted
         current_order = sys.maxint
         number_to_readd = 0
         current = self
-        key = (name, index)
+        key = (name, attrkind)
         while True:
             attr = None
             if current.cache_attrs is not None:
@@ -182,7 +182,7 @@ class AbstractAttribute(object):
                 # we reached the top, so we didn't find it anywhere,
                 # just add it to the top attribute
                 if not isinstance(current, PlainAttribute):
-                    return 0, self._get_new_attr(name, index)
+                    return 0, self._get_new_attr(name, attrkind)
 
             else:
                 return number_to_readd, attr
@@ -191,11 +191,11 @@ class AbstractAttribute(object):
             current_order = current.order
             current = current.back
 
-    @jit.look_inside_iff(lambda self, obj, name, index, w_value:
+    @jit.look_inside_iff(lambda self, obj, name, attrkind, w_value:
             jit.isconstant(self) and
             jit.isconstant(name) and
-            jit.isconstant(index))
-    def _reorder_and_add(self, obj, name, index, w_value):
+            jit.isconstant(attrkind))
+    def _reorder_and_add(self, obj, name, attrkind, w_value):
         # the idea is as follows: the subtrees of any map are ordered by
         # insertion.  the invariant is that subtrees that are inserted later
         # must not contain the name of the attribute of any earlier inserted
@@ -219,7 +219,7 @@ class AbstractAttribute(object):
         stack_index = 0
         while True:
             current = self
-            number_to_readd, attr = self._find_branch_to_move_into(name, index)
+            number_to_readd, attr = self._find_branch_to_move_into(name, attrkind)
             # we found the attributes further up, need to save the
             # previous values of the attributes we passed
             if number_to_readd:
@@ -244,7 +244,7 @@ class AbstractAttribute(object):
             next_map = unerase_map(stack[stack_index])
             w_value = unerase_item(stack[stack_index + 1])
             name = next_map.name
-            index = next_map.index
+            attrkind = next_map.attrkind
             self = obj._get_mapdict_map()
 
     def materialize_r_dict(self, space, obj, dict_w):
@@ -267,12 +267,12 @@ class Terminator(AbstractAttribute):
         AbstractAttribute.__init__(self, space, self)
         self.w_cls = w_cls
 
-    def _read_terminator(self, obj, name, index):
+    def _read_terminator(self, obj, name, attrkind):
         return None
 
-    def _write_terminator(self, obj, name, index, w_value):
-        obj._get_mapdict_map().add_attr(obj, name, index, w_value)
-        if index == DICT and obj._get_mapdict_map().length() >= LIMIT_MAP_ATTRIBUTES:
+    def _write_terminator(self, obj, name, attrkind, w_value):
+        obj._get_mapdict_map().add_attr(obj, name, attrkind, w_value)
+        if attrkind == DICT and obj._get_mapdict_map().length() >= LIMIT_MAP_ATTRIBUTES:
             space = self.space
             w_dict = obj.getdict(space)
             assert isinstance(w_dict, W_DictMultiObject)
@@ -322,31 +322,31 @@ class DictTerminator(Terminator):
 
 
 class NoDictTerminator(Terminator):
-    def _write_terminator(self, obj, name, index, w_value):
-        if index == DICT:
+    def _write_terminator(self, obj, name, attrkind, w_value):
+        if attrkind == DICT:
             return False
-        return Terminator._write_terminator(self, obj, name, index, w_value)
+        return Terminator._write_terminator(self, obj, name, attrkind, w_value)
 
 
 class DevolvedDictTerminator(Terminator):
-    def _read_terminator(self, obj, name, index):
-        if index == DICT:
+    def _read_terminator(self, obj, name, attrkind):
+        if attrkind == DICT:
             space = self.space
             w_dict = obj.getdict(space)
             return space.finditem_str(w_dict, name)
-        return Terminator._read_terminator(self, obj, name, index)
+        return Terminator._read_terminator(self, obj, name, attrkind)
 
-    def _write_terminator(self, obj, name, index, w_value):
-        if index == DICT:
+    def _write_terminator(self, obj, name, attrkind, w_value):
+        if attrkind == DICT:
             space = self.space
             w_dict = obj.getdict(space)
             space.setitem_str(w_dict, name, w_value)
             return True
-        return Terminator._write_terminator(self, obj, name, index, w_value)
+        return Terminator._write_terminator(self, obj, name, attrkind, w_value)
 
-    def delete(self, obj, name, index):
+    def delete(self, obj, name, attrkind):
         from pypy.interpreter.error import OperationError
-        if index == DICT:
+        if attrkind == DICT:
             space = self.space
             w_dict = obj.getdict(space)
             try:
@@ -355,7 +355,7 @@ class DevolvedDictTerminator(Terminator):
                 if not ex.match(space, space.w_KeyError):
                     raise
             return Terminator.copy(self, obj)
-        return Terminator.delete(self, obj, name, index)
+        return Terminator.delete(self, obj, name, attrkind)
 
     def remove_dict_entries(self, obj):
         assert 0, "should be unreachable"
@@ -367,12 +367,12 @@ class DevolvedDictTerminator(Terminator):
         return Terminator.set_terminator(self, obj, terminator)
 
 class PlainAttribute(AbstractAttribute):
-    _immutable_fields_ = ['name', 'index', 'storageindex', 'back', 'ever_mutated?', 'order']
+    _immutable_fields_ = ['name', 'attrkind', 'storageindex', 'back', 'ever_mutated?', 'order']
 
-    def __init__(self, name, index, back):
+    def __init__(self, name, attrkind, back):
         AbstractAttribute.__init__(self, back.space, back.terminator)
         self.name = name
-        self.index = index
+        self.attrkind = attrkind
         self.storageindex = back.length()
         self.back = back
         self._size_estimate = self.length() * NUM_DIGITS_POW2
@@ -380,16 +380,16 @@ class PlainAttribute(AbstractAttribute):
         self.order = len(back.cache_attrs) if back.cache_attrs else 0
 
     def _copy_attr(self, obj, new_obj):
-        w_value = self.read(obj, self.name, self.index)
-        new_obj._get_mapdict_map().add_attr(new_obj, self.name, self.index, w_value)
+        w_value = self.read(obj, self.name, self.attrkind)
+        new_obj._get_mapdict_map().add_attr(new_obj, self.name, self.attrkind, w_value)
 
-    def delete(self, obj, name, index):
-        if index == self.index and name == self.name:
+    def delete(self, obj, name, attrkind):
+        if attrkind == self.attrkind and name == self.name:
             # ok, attribute is deleted
             if not self.ever_mutated:
                 self.ever_mutated = True
             return self.back.copy(obj)
-        new_obj = self.back.delete(obj, name, index)
+        new_obj = self.back.delete(obj, name, attrkind)
         if new_obj is not None:
             self._copy_attr(obj, new_obj)
         return new_obj
@@ -408,13 +408,13 @@ class PlainAttribute(AbstractAttribute):
         return new_obj
 
     def search(self, attrtype):
-        if self.index == attrtype:
+        if self.attrkind == attrtype:
             return self
         return self.back.search(attrtype)
 
     def materialize_r_dict(self, space, obj, dict_w):
         new_obj = self.back.materialize_r_dict(space, obj, dict_w)
-        if self.index == DICT:
+        if self.attrkind == DICT:
             w_attr = space.newtext(self.name)
             dict_w[w_attr] = obj._mapdict_read_storage(self.storageindex)
         else:
@@ -423,7 +423,7 @@ class PlainAttribute(AbstractAttribute):
 
     def materialize_str_dict(self, space, obj, str_dict):
         new_obj = self.back.materialize_str_dict(space, obj, str_dict)
-        if self.index == DICT:
+        if self.attrkind == DICT:
             str_dict[self.name] = obj._mapdict_read_storage(self.storageindex)
         else:
             self._copy_attr(obj, new_obj)
@@ -431,12 +431,12 @@ class PlainAttribute(AbstractAttribute):
 
     def remove_dict_entries(self, obj):
         new_obj = self.back.remove_dict_entries(obj)
-        if self.index != DICT:
+        if self.attrkind != DICT:
             self._copy_attr(obj, new_obj)
         return new_obj
 
     def __repr__(self):
-        return "<PlainAttribute %s %s %s %r>" % (self.name, self.index, self.storageindex, self.back)
+        return "<PlainAttribute %s %s %s %r>" % (self.name, self.attrkind, self.storageindex, self.back)
 
 class MapAttrCache(object):
     def __init__(self, space):
@@ -504,16 +504,16 @@ class BaseUserClassMapdict:
     # methods needed for slots
 
     def getslotvalue(self, slotindex):
-        index = SLOTS_STARTING_FROM + slotindex
-        return self._get_mapdict_map().read(self, "slot", index)
+        attrkind = SLOTS_STARTING_FROM + slotindex
+        return self._get_mapdict_map().read(self, "slot", attrkind)
 
     def setslotvalue(self, slotindex, w_value):
-        index = SLOTS_STARTING_FROM + slotindex
-        self._get_mapdict_map().write(self, "slot", index, w_value)
+        attrkind = SLOTS_STARTING_FROM + slotindex
+        self._get_mapdict_map().write(self, "slot", attrkind, w_value)
 
     def delslotvalue(self, slotindex):
-        index = SLOTS_STARTING_FROM + slotindex
-        new_obj = self._get_mapdict_map().delete(self, "slot", index)
+        attrkind = SLOTS_STARTING_FROM + slotindex
+        new_obj = self._get_mapdict_map().delete(self, "slot", attrkind)
         if new_obj is None:
             return False
         self._set_mapdict_storage_and_map(new_obj.storage, new_obj.map)
@@ -1064,9 +1064,9 @@ def LOAD_ATTR_slowpath(pycode, w_obj, nameindex, map):
             _, w_descr = w_type._pure_lookup_where_with_method_cache(
                 name, version_tag)
             #
-            attrname, index = ("", INVALID)
+            attrname, attrkind = ("", INVALID)
             if w_descr is None:
-                attrname, index = (name, DICT) # common case: no such attr in the class
+                attrname, attrkind = (name, DICT) # common case: no such attr in the class
             elif isinstance(w_descr, MutableCell):
                 pass              # we have a MutableCell in the class: give up
             elif space.is_data_descr(w_descr):
@@ -1074,7 +1074,7 @@ def LOAD_ATTR_slowpath(pycode, w_obj, nameindex, map):
                 # (if any) has no relevance.
                 from pypy.interpreter.typedef import Member
                 if isinstance(w_descr, Member):    # it is a slot -- easy case
-                    attrname, index = ("slot", SLOTS_STARTING_FROM + w_descr.index)
+                    attrname, attrkind = ("slot", SLOTS_STARTING_FROM + w_descr.index)
             else:
                 # There is a non-data descriptor in the class.  If there is
                 # also a dict attribute, use the latter, caching its storageindex.
@@ -1082,14 +1082,14 @@ def LOAD_ATTR_slowpath(pycode, w_obj, nameindex, map):
                 # but we don't care too much; the common case of a method
                 # invocation is handled by LOOKUP_METHOD_xxx below.
                 attrname = name
-                index = DICT
+                attrkind = DICT
             #
-            if index != INVALID:
-                attr = map.find_map_attr(attrname, index)
+            if attrkind != INVALID:
+                attr = map.find_map_attr(attrname, attrkind)
                 if attr is not None:
                     # Note that if map.terminator is a DevolvedDictTerminator
                     # or the class provides its own dict, not using mapdict, then:
-                    # map.find_map_attr will always return None if index==DICT.
+                    # map.find_map_attr will always return None if attrkind==DICT.
                     _fill_cache(pycode, nameindex, map, version_tag, attr.storageindex)
                     return w_obj._mapdict_read_storage(attr.storageindex)
     if space.config.objspace.std.withmethodcachecounter: