Some nodes got a new attribute, 'ctx', which tells in which context the said node was used.

The possible values for the contexts are `Load` ('a'), `Del` ('del a'),
`Store` ('a = 4') and the nodes that got the new attribute are Starred,
Subscript, List and Tuple. The builtin ast module provides contexts for
Name and Attribute as well, but we took a different approach in the past,
by having different nodes for each type of context. For instance, Name
used in a Del context is a DelName, while Name used in a Store
context is AssignName. Since this is ingrained in astroid since quite
some time, it makes no sense to change them as well, even though it's
a loss of consistency.
The patch introduces a new dependency to enum34 on older Python
versions, which is used for building the three possible enum values
for the contexts.

Closes issue #267.

6 files changed, 337 insertions, 236 deletions

diff --git a/ChangeLog b/ChangeLog
index c064fef..b3737d4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -2,6 +2,14 @@ Change log for the astroid package (used to be astng)
 =====================================================
 
 --
+
+    * Some nodes got a new attribute, 'ctx', which tells in which context
+      the said node was used.
+
+      The possible values for the contexts are `Load` ('a'), `Del`
+      ('del a'), `Store` ('a = 4') and the nodes that got the new
+      attribute are Starred, Subscript, List and Tuple. Closes issue #267.
+
     * relative_to_absolute_name or methods calling it will now raise
       TooManyLevelsError when a relative import was trying to
       access something beyond the top-level package.     
diff --git a/astroid/__init__.py b/astroid/__init__.py
index fee55f5..54d861a 100644
--- a/astroid/__init__.py
+++ b/astroid/__init__.py
@@ -44,6 +44,16 @@ import sys
 import re
 from operator import attrgetter
 
+import enum
+
+
+_Context = enum.Enum('Context', 'Load Store Del')
+Load = _Context.Load
+Store = _Context.Store
+Del = _Context.Del
+del _Context
+
+
 # WARNING: internal imports order matters !
 
 # pylint: disable=redefined-builtin, wildcard-import
diff --git a/astroid/__pkginfo__.py b/astroid/__pkginfo__.py
index d122902..3686d03 100644
--- a/astroid/__pkginfo__.py
+++ b/astroid/__pkginfo__.py
@@ -25,10 +25,10 @@ modname = 'astroid'
 numversion = (1, 5, 0)
 version = '.'.join([str(num) for num in numversion])
 
-if sys.version_info >= (3, 4):
-    install_requires = ['lazy_object_proxy', 'six', 'wrapt']
-else:
-    install_requires = ['lazy_object_proxy', 'singledispatch', 'six', 'wrapt']
+install_requires = ['lazy_object_proxy', 'six', 'wrapt']
+
+if sys.version_info < (3, 4):
+    install_requires += ['enum34', 'singledispatch']
 
 license = 'LGPL'
 
diff --git a/astroid/node_classes.py b/astroid/node_classes.py
index b004785..175de6d 100644
--- a/astroid/node_classes.py
+++ b/astroid/node_classes.py
@@ -1524,6 +1524,12 @@ class Keyword(NodeNG):
 
 class List(_BaseContainer):
     """class representing a List node"""
+    _other_fields = ('ctx',)
+
+    def __init__(self, ctx=None, lineno=None,
+                 col_offset=None, parent=None):
+        self.ctx = ctx
+        super(List, self).__init__(lineno, col_offset, parent)
 
     def pytype(self):
         return '%s.list' % BUILTINS
@@ -1654,8 +1660,14 @@ class Slice(NodeNG):
 class Starred(mixins.ParentAssignTypeMixin, NodeNG):
     """class representing a Starred node"""
     _astroid_fields = ('value',)
+    _other_fields = ('ctx', )
     value = None
 
+    def __init__(self, ctx=None, lineno=None, col_offset=None, parent=None):
+        self.ctx = ctx
+        super(Starred, self).__init__(lineno=lineno,
+                                      col_offset=col_offset, parent=parent)
+
     def postinit(self, value=None):
         self.value = value
 
@@ -1663,9 +1675,15 @@ class Starred(mixins.ParentAssignTypeMixin, NodeNG):
 class Subscript(NodeNG):
     """class representing a Subscript node"""
     _astroid_fields = ('value', 'slice')
+    _other_fields = ('ctx', )
     value = None
     slice = None
 
+    def __init__(self, ctx=None, lineno=None, col_offset=None, parent=None):
+        self.ctx = ctx
+        super(Subscript, self).__init__(lineno=lineno,
+                                        col_offset=col_offset, parent=parent)
+
     def postinit(self, value=None, slice=None):
         self.value = value
         self.slice = slice
@@ -1722,6 +1740,13 @@ class TryFinally(mixins.BlockRangeMixIn, Statement):
 class Tuple(_BaseContainer):
     """class representing a Tuple node"""
 
+    _other_fields = ('ctx',)
+
+    def __init__(self, ctx=None, lineno=None,
+                 col_offset=None, parent=None):
+        self.ctx = ctx
+        super(Tuple, self).__init__(lineno, col_offset, parent)
+
     def pytype(self):
         return '%s.tuple' % BUILTINS
 
diff --git a/astroid/rebuilder.py b/astroid/rebuilder.py
index cab9317..a07fe29 100644
--- a/astroid/rebuilder.py
+++ b/astroid/rebuilder.py
@@ -22,6 +22,7 @@ order to get a single Astroid representation
 import _ast
 import sys
 
+import astroid
 from astroid import astpeephole
 from astroid import nodes
 
@@ -79,6 +80,11 @@ REDIRECT = {'arguments': 'Arguments',
            }
 PY3 = sys.version_info >= (3, 0)
 PY34 = sys.version_info >= (3, 4)
+CONTEXTS = {_ast.Load: astroid.Load,
+            _ast.Store: astroid.Store,
+            _ast.Del: astroid.Del,
+            _ast.Param: astroid.Store}
+
 
 def _get_doc(node):
     try:
@@ -90,7 +96,7 @@ def _get_doc(node):
         pass # ast built from scratch
     return node, None
 
-def _visit_or_none(node, attr, visitor, parent, assign_ctx, visit='visit',
+def _visit_or_none(node, attr, visitor, parent, visit='visit',
                    **kws):
     """If the given node has an attribute, visits the attribute, and
     otherwise returns None.
@@ -98,11 +104,15 @@ def _visit_or_none(node, attr, visitor, parent, assign_ctx, visit='visit',
     """
     value = getattr(node, attr, None)
     if value:
-        return getattr(visitor, visit)(value, parent, assign_ctx, **kws)
+        return getattr(visitor, visit)(value, parent, **kws)
     else:
         return None
 
 
+def _get_context(node):
+    return CONTEXTS.get(type(node.ctx), astroid.Load)
+
+
 class TreeRebuilder(object):
     """Rebuilds the _ast tree to become an Astroid tree"""
 
@@ -122,7 +132,7 @@ class TreeRebuilder(object):
         newnode.postinit([self.visit(child, newnode) for child in node.body])
         return newnode
 
-    def visit(self, node, parent, assign_ctx=None):
+    def visit(self, node, parent):
         cls = node.__class__
         if cls in self._visit_meths:
             visit_method = self._visit_meths[cls]
@@ -131,7 +141,7 @@ class TreeRebuilder(object):
             visit_name = 'visit_' + REDIRECT.get(cls_name, cls_name).lower()
             visit_method = getattr(self, visit_name)
             self._visit_meths[cls] = visit_method
-        return visit_method(node, parent, assign_ctx)
+        return visit_method(node, parent)
 
     def _save_assignment(self, node, name=None):
         """save assignement situation since node.parent is not available yet"""
@@ -140,7 +150,7 @@ class TreeRebuilder(object):
         else:
             node.parent.set_local(node.name, node)
 
-    def visit_arguments(self, node, parent, assign_ctx=None):
+    def visit_arguments(self, node, parent):
         """visit a Arguments node by returning a fresh instance of it"""
         vararg, kwarg = node.vararg, node.kwarg
         if PY34:
@@ -149,8 +159,8 @@ class TreeRebuilder(object):
                                       parent)
         else:
             newnode = nodes.Arguments(vararg, kwarg, parent)
-        args = [self.visit(child, newnode, "Assign") for child in node.args]
-        defaults = [self.visit(child, newnode, assign_ctx)
+        args = [self.visit(child, newnode) for child in node.args]
+        defaults = [self.visit(child, newnode)
                     for child in node.defaults]
         varargannotation = None
         kwargannotation = None
@@ -160,27 +170,27 @@ class TreeRebuilder(object):
             if PY34:
                 if node.vararg.annotation:
                     varargannotation = self.visit(node.vararg.annotation,
-                                                  newnode, assign_ctx)
+                                                  newnode)
                 vararg = vararg.arg
             elif PY3 and node.varargannotation:
                 varargannotation = self.visit(node.varargannotation,
-                                              newnode, assign_ctx)
+                                              newnode)
         if kwarg:
             if PY34:
                 if node.kwarg.annotation:
                     kwargannotation = self.visit(node.kwarg.annotation,
-                                                 newnode, assign_ctx)
+                                                 newnode)
                 kwarg = kwarg.arg
             elif PY3:
                 if node.kwargannotation:
                     kwargannotation = self.visit(node.kwargannotation,
-                                                 newnode, assign_ctx)
+                                                 newnode)
         if PY3:
-            kwonlyargs = [self.visit(child, newnode, "Assign") for child
+            kwonlyargs = [self.visit(child, newnode) for child
                           in node.kwonlyargs]
-            kw_defaults = [self.visit(child, newnode, None) if child else
+            kw_defaults = [self.visit(child, newnode) if child else
                            None for child in node.kw_defaults]
-            annotations = [self.visit(arg.annotation, newnode, None) if
+            annotations = [self.visit(arg.annotation, newnode) if
                            arg.annotation else None for arg in node.args]
         else:
             kwonlyargs = []
@@ -195,48 +205,46 @@ class TreeRebuilder(object):
             newnode.parent.set_local(kwarg, newnode)
         return newnode
 
-    def visit_assert(self, node, parent, assign_ctx=None):
+    def visit_assert(self, node, parent):
         """visit a Assert node by returning a fresh instance of it"""
         newnode = nodes.Assert(node.lineno, node.col_offset, parent)
         if node.msg:
-            msg = self.visit(node.msg, newnode, assign_ctx)
+            msg = self.visit(node.msg, newnode)
         else:
             msg = None
-        newnode.postinit(self.visit(node.test, newnode, assign_ctx), msg)
+        newnode.postinit(self.visit(node.test, newnode), msg)
         return newnode
 
-    def visit_assign(self, node, parent, assign_ctx=None):
+    def visit_assign(self, node, parent):
         """visit a Assign node by returning a fresh instance of it"""
         newnode = nodes.Assign(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, "Assign")
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.targets],
-                         self.visit(node.value, newnode, None))
+                         self.visit(node.value, newnode))
         return newnode
 
-    def visit_assignname(self, node, parent, assign_ctx=None, node_name=None):
+    def visit_assignname(self, node, parent, node_name=None):
         '''visit a node and return a AssignName node'''
-        # assign_ctx is not used here, it takes that argument only to
-        # maintain consistency with the other visit functions.
         newnode = nodes.AssignName(node_name, getattr(node, 'lineno', None),
                                    getattr(node, 'col_offset', None), parent)
         self._save_assignment(newnode)
         return newnode
 
-    def visit_augassign(self, node, parent, assign_ctx=None):
+    def visit_augassign(self, node, parent):
         """visit a AugAssign node by returning a fresh instance of it"""
         newnode = nodes.AugAssign(_BIN_OP_CLASSES[type(node.op)] + "=",
                                   node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.target, newnode, "Assign"),
-                         self.visit(node.value, newnode, None))
+        newnode.postinit(self.visit(node.target, newnode),
+                         self.visit(node.value, newnode))
         return newnode
 
-    def visit_repr(self, node, parent, assign_ctx=None):
+    def visit_repr(self, node, parent):
         """visit a Backquote node by returning a fresh instance of it"""
         newnode = nodes.Repr(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_binop(self, node, parent, assign_ctx=None):
+    def visit_binop(self, node, parent):
         """visit a BinOp node by returning a fresh instance of it"""
         if isinstance(node.left, _ast.BinOp) and self._manager.optimize_ast:
             # Optimize BinOp operations in order to remove
@@ -257,36 +265,34 @@ class TreeRebuilder(object):
 
         newnode = nodes.BinOp(_BIN_OP_CLASSES[type(node.op)],
                               node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.left, newnode, assign_ctx),
-                         self.visit(node.right, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.left, newnode),
+                         self.visit(node.right, newnode))
         return newnode
 
-    def visit_boolop(self, node, parent, assign_ctx=None):
+    def visit_boolop(self, node, parent):
         """visit a BoolOp node by returning a fresh instance of it"""
         newnode = nodes.BoolOp(_BOOL_OP_CLASSES[type(node.op)],
                                node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.values])
         return newnode
 
-    def visit_break(self, node, parent, assign_ctx=None):
+    def visit_break(self, node, parent):
         """visit a Break node by returning a fresh instance of it"""
         return nodes.Break(getattr(node, 'lineno', None),
                            getattr(node, 'col_offset', None),
                            parent)
 
-    def visit_call(self, node, parent, assign_ctx=None):
+    def visit_call(self, node, parent):
         """visit a CallFunc node by returning a fresh instance of it"""
         newnode = nodes.Call(node.lineno, node.col_offset, parent)
-        starargs = _visit_or_none(node, 'starargs', self, newnode,
-                                  assign_ctx)
-        kwargs = _visit_or_none(node, 'kwargs', self, newnode,
-                                assign_ctx)
-        args = [self.visit(child, newnode, assign_ctx)
+        starargs = _visit_or_none(node, 'starargs', self, newnode)
+        kwargs = _visit_or_none(node, 'kwargs', self, newnode)
+        args = [self.visit(child, newnode)
                 for child in node.args]
 
         if node.keywords:
-            keywords = [self.visit(child, newnode, assign_ctx)
+            keywords = [self.visit(child, newnode)
                         for child in node.keywords]
         else:
             keywords = None
@@ -306,11 +312,11 @@ class TreeRebuilder(object):
             else:
                 keywords = [new_kwargs]
 
-        newnode.postinit(self.visit(node.func, newnode, assign_ctx),
+        newnode.postinit(self.visit(node.func, newnode),
                          args, keywords)
         return newnode
 
-    def visit_classdef(self, node, parent, assign_ctx=None, newstyle=None):
+    def visit_classdef(self, node, parent, newstyle=None):
         """visit a ClassDef node to become astroid"""
         node, doc = _get_doc(node)
         newnode = nodes.ClassDef(node.name, doc, node.lineno,
@@ -319,153 +325,150 @@ class TreeRebuilder(object):
         if PY3:
             for keyword in node.keywords:
                 if keyword.arg == 'metaclass':
-                    metaclass = self.visit(keyword, newnode, assign_ctx).value
+                    metaclass = self.visit(keyword, newnode).value
                 break
         if node.decorator_list:
-            decorators = self.visit_decorators(node, newnode, assign_ctx)
+            decorators = self.visit_decorators(node, newnode)
         else:
             decorators = None
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.bases],
-                         [self.visit(child, newnode, assign_ctx)
+                         [self.visit(child, newnode)
                           for child in node.body],
                          decorators, newstyle, metaclass)
         return newnode
 
-    def visit_const(self, node, parent, assign_ctx=None):
+    def visit_const(self, node, parent):
         """visit a Const node by returning a fresh instance of it"""
         return nodes.Const(node.value, getattr(node, 'lineno', None),
                            getattr(node, 'col_offset', None), parent)
 
-    def visit_continue(self, node, parent, assign_ctx=None):
+    def visit_continue(self, node, parent):
         """visit a Continue node by returning a fresh instance of it"""
         return nodes.Continue(getattr(node, 'lineno', None),
                               getattr(node, 'col_offset', None),
                               parent)
 
-    def visit_compare(self, node, parent, assign_ctx=None):
+    def visit_compare(self, node, parent):
         """visit a Compare node by returning a fresh instance of it"""
         newnode = nodes.Compare(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.left, newnode, assign_ctx),
+        newnode.postinit(self.visit(node.left, newnode),
                          [(_CMP_OP_CLASSES[op.__class__],
-                           self.visit(expr, newnode, assign_ctx))
+                           self.visit(expr, newnode))
                           for (op, expr) in zip(node.ops, node.comparators)])
         return newnode
 
-    def visit_comprehension(self, node, parent, assign_ctx=None):
+    def visit_comprehension(self, node, parent):
         """visit a Comprehension node by returning a fresh instance of it"""
         newnode = nodes.Comprehension(parent)
-        newnode.postinit(self.visit(node.target, newnode, "Assign"),
-                         self.visit(node.iter, newnode, None),
-                         [self.visit(child, newnode, None)
+        newnode.postinit(self.visit(node.target, newnode),
+                         self.visit(node.iter, newnode),
+                         [self.visit(child, newnode)
                           for child in node.ifs])
         return newnode
 
-    def visit_decorators(self, node, parent, assign_ctx=None):
+    def visit_decorators(self, node, parent):
         """visit a Decorators node by returning a fresh instance of it"""
         # /!\ node is actually a _ast.FunctionDef node while
         # parent is a astroid.nodes.FunctionDef node
         newnode = nodes.Decorators(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.decorator_list])
         return newnode
 
-    def visit_delete(self, node, parent, assign_ctx=None):
+    def visit_delete(self, node, parent):
         """visit a Delete node by returning a fresh instance of it"""
         newnode = nodes.Delete(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, "Del")
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.targets])
         return newnode
 
-    def _visit_dict_items(self, node, parent, newnode, assign_ctx):
+    def _visit_dict_items(self, node, parent, newnode):
         for key, value in zip(node.keys, node.values):
-            rebuilt_value = self.visit(value, newnode, assign_ctx)
+            rebuilt_value = self.visit(value, newnode)
             if not key:
                 # Python 3.5 and extended unpacking
                 rebuilt_key = nodes.DictUnpack(rebuilt_value.lineno,
                                                rebuilt_value.col_offset,
                                                parent)
             else:
-                rebuilt_key = self.visit(key, newnode, assign_ctx)
+                rebuilt_key = self.visit(key, newnode)
             yield rebuilt_key, rebuilt_value
 
-    def visit_dict(self, node, parent, assign_ctx=None):
+    def visit_dict(self, node, parent):
         """visit a Dict node by returning a fresh instance of it"""
         newnode = nodes.Dict(node.lineno, node.col_offset, parent)
-        items = list(self._visit_dict_items(node, parent, newnode, assign_ctx))
+        items = list(self._visit_dict_items(node, parent, newnode))
         newnode.postinit(items)
         return newnode
 
-    def visit_dictcomp(self, node, parent, assign_ctx=None):
+    def visit_dictcomp(self, node, parent):
         """visit a DictComp node by returning a fresh instance of it"""
         newnode = nodes.DictComp(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.key, newnode, assign_ctx),
-                         self.visit(node.value, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.key, newnode),
+                         self.visit(node.value, newnode),
+                         [self.visit(child, newnode)
                           for child in node.generators])
         return newnode
 
-    def visit_expr(self, node, parent, assign_ctx=None):
+    def visit_expr(self, node, parent):
         """visit a Expr node by returning a fresh instance of it"""
         newnode = nodes.Expr(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_ellipsis(self, node, parent, assign_ctx=None):
+    def visit_ellipsis(self, node, parent):
         """visit an Ellipsis node by returning a fresh instance of it"""
         return nodes.Ellipsis(getattr(node, 'lineno', None),
                               getattr(node, 'col_offset', None), parent)
 
 
-    def visit_emptynode(self, node, parent, assign_ctx=None):
+    def visit_emptynode(self, node, parent):
         """visit an EmptyNode node by returning a fresh instance of it"""
         return nodes.EmptyNode(getattr(node, 'lineno', None),
                                getattr(node, 'col_offset', None), parent)
 
 
-    def visit_excepthandler(self, node, parent, assign_ctx=None):
+    def visit_excepthandler(self, node, parent):
         """visit an ExceptHandler node by returning a fresh instance of it"""
         newnode = nodes.ExceptHandler(node.lineno, node.col_offset, parent)
         # /!\ node.name can be a tuple
-        newnode.postinit(_visit_or_none(node, 'type', self, newnode, assign_ctx),
-                         _visit_or_none(node, 'name', self, newnode, 'Assign'),
-                         [self.visit(child, newnode, None)
+        newnode.postinit(_visit_or_none(node, 'type', self, newnode),
+                         _visit_or_none(node, 'name', self, newnode),
+                         [self.visit(child, newnode)
                           for child in node.body])
         return newnode
 
-    def visit_exec(self, node, parent, assign_ctx=None):
+    def visit_exec(self, node, parent):
         """visit an Exec node by returning a fresh instance of it"""
         newnode = nodes.Exec(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.body, newnode, assign_ctx),
-                         _visit_or_none(node, 'globals', self, newnode,
-                                        assign_ctx),
-                         _visit_or_none(node, 'locals', self, newnode,
-                                        assign_ctx))
+        newnode.postinit(self.visit(node.body, newnode),
+                         _visit_or_none(node, 'globals', self, newnode),
+                         _visit_or_none(node, 'locals', self, newnode))
         return newnode
 
-    def visit_extslice(self, node, parent, assign_ctx=None):
+    def visit_extslice(self, node, parent):
         """visit an ExtSlice node by returning a fresh instance of it"""
         newnode = nodes.ExtSlice(parent=parent)
-        newnode.postinit([self.visit(dim, newnode, assign_ctx)
+        newnode.postinit([self.visit(dim, newnode)
                           for dim in node.dims])
         return newnode
 
-    def _visit_for(self, cls, node, parent, assign_ctx=None):
+    def _visit_for(self, cls, node, parent):
         """visit a For node by returning a fresh instance of it"""
         newnode = cls(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.target, newnode, "Assign"),
-                         self.visit(node.iter, newnode, None),
-                         [self.visit(child, newnode, None)
+        newnode.postinit(self.visit(node.target, newnode),
+                         self.visit(node.iter, newnode),
+                         [self.visit(child, newnode)
                           for child in node.body],
-                         [self.visit(child, newnode, None)
+                         [self.visit(child, newnode)
                           for child in node.orelse])
         return newnode
 
-    def visit_for(self, node, parent, assign_ctx=None):
-        return self._visit_for(nodes.For, node, parent,
-                               assign_ctx=assign_ctx)
+    def visit_for(self, node, parent):
+        return self._visit_for(nodes.For, node, parent)
 
-    def visit_importfrom(self, node, parent, assign_ctx=None):
+    def visit_importfrom(self, node, parent):
         """visit an ImportFrom node by returning a fresh instance of it"""
         names = [(alias.name, alias.asname) for alias in node.names]
         newnode = nodes.ImportFrom(node.module or '', names, node.level or None,
@@ -475,57 +478,57 @@ class TreeRebuilder(object):
         self._import_from_nodes.append(newnode)
         return newnode
 
-    def _visit_functiondef(self, cls, node, parent, assign_ctx=None):
+    def _visit_functiondef(self, cls, node, parent):
         """visit an FunctionDef node to become astroid"""
         self._global_names.append({})
         node, doc = _get_doc(node)
         newnode = cls(node.name, doc, node.lineno,
                       node.col_offset, parent)
         if node.decorator_list:
-            decorators = self.visit_decorators(node, newnode, assign_ctx)
+            decorators = self.visit_decorators(node, newnode)
         else:
             decorators = None
         if PY3 and node.returns:
-            returns = self.visit(node.returns, newnode, assign_ctx)
+            returns = self.visit(node.returns, newnode)
         else:
             returns = None
-        newnode.postinit(self.visit(node.args, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.args, newnode),
+                         [self.visit(child, newnode)
                           for child in node.body],
                          decorators, returns)
         self._global_names.pop()
         return newnode
 
-    def visit_functiondef(self, node, parent, assign_ctx=None):
-        return self._visit_functiondef(nodes.FunctionDef, node, parent,
-                                       assign_ctx=assign_ctx)
+    def visit_functiondef(self, node, parent):
+        return self._visit_functiondef(nodes.FunctionDef, node, parent)
 
-    def visit_generatorexp(self, node, parent, assign_ctx=None):
+    def visit_generatorexp(self, node, parent):
         """visit a GeneratorExp node by returning a fresh instance of it"""
         newnode = nodes.GeneratorExp(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.elt, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.elt, newnode),
+                         [self.visit(child, newnode)
                           for child in node.generators])
         return newnode
 
-    def visit_attribute(self, node, parent, assign_ctx=None):
+    def visit_attribute(self, node, parent):
         """visit an Attribute node by returning a fresh instance of it"""
-        if assign_ctx == "Del":
+        context = _get_context(node)
+        if context == astroid.Del:
             # FIXME : maybe we should reintroduce and visit_delattr ?
             # for instance, deactivating assign_ctx
             newnode = nodes.DelAttr(node.attr, node.lineno, node.col_offset,
                                     parent)
-        elif assign_ctx == "Assign":
+        elif context == astroid.Store:
             newnode = nodes.AssignAttr(node.attr, node.lineno, node.col_offset,
                                        parent)
             self._delayed_assattr.append(newnode)
         else:
             newnode = nodes.Attribute(node.attr, node.lineno, node.col_offset,
                                       parent)
-        newnode.postinit(self.visit(node.value, newnode, None))
+        newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_global(self, node, parent, assign_ctx=None):
+    def visit_global(self, node, parent):
         """visit a Global node to become astroid"""
         newnode = nodes.Global(node.names, getattr(node, 'lineno', None),
                                getattr(node, 'col_offset', None), parent)
@@ -534,25 +537,25 @@ class TreeRebuilder(object):
                 self._global_names[-1].setdefault(name, []).append(newnode)
         return newnode
 
-    def visit_if(self, node, parent, assign_ctx=None):
+    def visit_if(self, node, parent):
         """visit an If node by returning a fresh instance of it"""
         newnode = nodes.If(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.test, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.test, newnode),
+                         [self.visit(child, newnode)
                           for child in node.body],
-                         [self.visit(child, newnode, assign_ctx)
+                         [self.visit(child, newnode)
                           for child in node.orelse])
         return newnode
 
-    def visit_ifexp(self, node, parent, assign_ctx=None):
+    def visit_ifexp(self, node, parent):
         """visit a IfExp node by returning a fresh instance of it"""
         newnode = nodes.IfExp(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.test, newnode, assign_ctx),
-                         self.visit(node.body, newnode, assign_ctx),
-                         self.visit(node.orelse, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.test, newnode),
+                         self.visit(node.body, newnode),
+                         self.visit(node.orelse, newnode))
         return newnode
 
-    def visit_import(self, node, parent, assign_ctx=None):
+    def visit_import(self, node, parent):
         """visit a Import node by returning a fresh instance of it"""
         names = [(alias.name, alias.asname) for alias in node.names]
         newnode = nodes.Import(names, getattr(node, 'lineno', None),
@@ -563,49 +566,53 @@ class TreeRebuilder(object):
             parent.set_local(name.split('.')[0], newnode)
         return newnode
 
-    def visit_index(self, node, parent, assign_ctx=None):
+    def visit_index(self, node, parent):
         """visit a Index node by returning a fresh instance of it"""
         newnode = nodes.Index(parent=parent)
-        newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_keyword(self, node, parent, assign_ctx=None):
+    def visit_keyword(self, node, parent):
         """visit a Keyword node by returning a fresh instance of it"""
         newnode = nodes.Keyword(node.arg, parent=parent)
-        newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_lambda(self, node, parent, assign_ctx=None):
+    def visit_lambda(self, node, parent):
         """visit a Lambda node by returning a fresh instance of it"""
         newnode = nodes.Lambda(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.args, newnode, assign_ctx),
-                         self.visit(node.body, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.args, newnode),
+                         self.visit(node.body, newnode))
         return newnode
 
-    def visit_list(self, node, parent, assign_ctx=None):
+    def visit_list(self, node, parent):
         """visit a List node by returning a fresh instance of it"""
-        newnode = nodes.List(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        context = _get_context(node)
+        newnode = nodes.List(ctx=context,
+                             lineno=node.lineno,
+                             col_offset=node.col_offset,
+                             parent=parent)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.elts])
         return newnode
 
-    def visit_listcomp(self, node, parent, assign_ctx=None):
+    def visit_listcomp(self, node, parent):
         """visit a ListComp node by returning a fresh instance of it"""
         newnode = nodes.ListComp(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.elt, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.elt, newnode),
+                         [self.visit(child, newnode)
                           for child in node.generators])
         return newnode
 
-    def visit_name(self, node, parent, assign_ctx=None):
+    def visit_name(self, node, parent):
         """visit a Name node by returning a fresh instance of it"""
+        context = _get_context(node)
         # True and False can be assigned to something in py2x, so we have to
-        # check first the assign_ctx
-        if assign_ctx == "Del":
+        # check first the context.
+        if context == astroid.Del:
             newnode = nodes.DelName(node.id, node.lineno, node.col_offset,
                                     parent)
-        elif assign_ctx is not None: # Assign
-            assert assign_ctx == "Assign"
+        elif context == astroid.Store:
             newnode = nodes.AssignName(node.id, node.lineno, node.col_offset,
                                        parent)
         elif node.id in CONST_NAME_TRANSFORMS:
@@ -616,257 +623,258 @@ class TreeRebuilder(object):
         else:
             newnode = nodes.Name(node.id, node.lineno, node.col_offset, parent)
         # XXX REMOVE me :
-        if assign_ctx in ('Del', 'Assign'): # 'Aug' ??
+        if context in (astroid.Del, astroid.Store): # 'Aug' ??
             self._save_assignment(newnode)
         return newnode
 
-    def visit_str(self, node, parent, assign_ctx=None):
+    def visit_str(self, node, parent):
         """visit a String/Bytes node by returning a fresh instance of Const"""
         return nodes.Const(node.s, getattr(node, 'lineno', None),
                            getattr(node, 'col_offset', None), parent)
     visit_bytes = visit_str
 
-    def visit_num(self, node, parent, assign_ctx=None):
+    def visit_num(self, node, parent):
         """visit a Num node by returning a fresh instance of Const"""
         return nodes.Const(node.n, getattr(node, 'lineno', None),
                            getattr(node, 'col_offset', None), parent)
 
-    def visit_pass(self, node, parent, assign_ctx=None):
+    def visit_pass(self, node, parent):
         """visit a Pass node by returning a fresh instance of it"""
         return nodes.Pass(node.lineno, node.col_offset, parent)
 
-    def visit_print(self, node, parent, assign_ctx=None):
+    def visit_print(self, node, parent):
         """visit a Print node by returning a fresh instance of it"""
         newnode = nodes.Print(node.nl, node.lineno, node.col_offset, parent)
-        newnode.postinit(_visit_or_none(node, 'dest', self, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(_visit_or_none(node, 'dest', self, newnode),
+                         [self.visit(child, newnode)
                           for child in node.values])
         return newnode
 
-    def visit_raise(self, node, parent, assign_ctx=None):
+    def visit_raise(self, node, parent):
         """visit a Raise node by returning a fresh instance of it"""
         newnode = nodes.Raise(node.lineno, node.col_offset, parent)
-        newnode.postinit(_visit_or_none(node, 'type', self, newnode, assign_ctx),
-                         _visit_or_none(node, 'inst', self, newnode, assign_ctx),
-                         _visit_or_none(node, 'tback', self, newnode,
-                                        assign_ctx))
+        newnode.postinit(_visit_or_none(node, 'type', self, newnode),
+                         _visit_or_none(node, 'inst', self, newnode),
+                         _visit_or_none(node, 'tback', self, newnode))
         return newnode
 
-    def visit_return(self, node, parent, assign_ctx=None):
+    def visit_return(self, node, parent):
         """visit a Return node by returning a fresh instance of it"""
         newnode = nodes.Return(node.lineno, node.col_offset, parent)
         if node.value is not None:
-            newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+            newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_set(self, node, parent, assign_ctx=None):
+    def visit_set(self, node, parent):
         """visit a Set node by returning a fresh instance of it"""
         newnode = nodes.Set(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.elts])
         return newnode
 
-    def visit_setcomp(self, node, parent, assign_ctx=None):
+    def visit_setcomp(self, node, parent):
         """visit a SetComp node by returning a fresh instance of it"""
         newnode = nodes.SetComp(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.elt, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.elt, newnode),
+                         [self.visit(child, newnode)
                           for child in node.generators])
         return newnode
 
-    def visit_slice(self, node, parent, assign_ctx=None):
+    def visit_slice(self, node, parent):
         """visit a Slice node by returning a fresh instance of it"""
         newnode = nodes.Slice(parent=parent)
-        newnode.postinit(_visit_or_none(node, 'lower', self, newnode,
-                                        assign_ctx),
-                         _visit_or_none(node, 'upper', self, newnode,
-                                        assign_ctx),
-                         _visit_or_none(node, 'step', self, newnode, assign_ctx))
+        newnode.postinit(_visit_or_none(node, 'lower', self, newnode),
+                         _visit_or_none(node, 'upper', self, newnode),
+                         _visit_or_none(node, 'step', self, newnode))
         return newnode
 
-    def visit_subscript(self, node, parent, assign_ctx=None):
+    def visit_subscript(self, node, parent):
         """visit a Subscript node by returning a fresh instance of it"""
-        newnode = nodes.Subscript(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.value, newnode, None),
-                         self.visit(node.slice, newnode, None))
+        context = _get_context(node)
+        newnode = nodes.Subscript(ctx=context,
+                                  lineno=node.lineno,
+                                  col_offset=node.col_offset,
+                                  parent=parent)
+        newnode.postinit(self.visit(node.value, newnode),
+                         self.visit(node.slice, newnode))
         return newnode
 
-    def visit_tryexcept(self, node, parent, assign_ctx=None):
+    def visit_tryexcept(self, node, parent):
         """visit a TryExcept node by returning a fresh instance of it"""
         newnode = nodes.TryExcept(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.body],
-                         [self.visit(child, newnode, assign_ctx)
+                         [self.visit(child, newnode)
                           for child in node.handlers],
-                         [self.visit(child, newnode, assign_ctx)
+                         [self.visit(child, newnode)
                           for child in node.orelse])
         return newnode
 
-    def visit_tryfinally(self, node, parent, assign_ctx=None):
+    def visit_tryfinally(self, node, parent):
         """visit a TryFinally node by returning a fresh instance of it"""
         newnode = nodes.TryFinally(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.body],
-                         [self.visit(n, newnode, assign_ctx)
+                         [self.visit(n, newnode)
                           for n in node.finalbody])
         return newnode
 
-    def visit_tuple(self, node, parent, assign_ctx=None):
+    def visit_tuple(self, node, parent):
         """visit a Tuple node by returning a fresh instance of it"""
-        newnode = nodes.Tuple(node.lineno, node.col_offset, parent)
-        newnode.postinit([self.visit(child, newnode, assign_ctx)
+        context = _get_context(node)
+        newnode = nodes.Tuple(ctx=context,
+                              lineno=node.lineno,
+                              col_offset=node.col_offset,
+                              parent=parent)
+        newnode.postinit([self.visit(child, newnode)
                           for child in node.elts])
         return newnode
 
-    def visit_unaryop(self, node, parent, assign_ctx=None):
+    def visit_unaryop(self, node, parent):
         """visit a UnaryOp node by returning a fresh instance of it"""
         newnode = nodes.UnaryOp(_UNARY_OP_CLASSES[node.op.__class__],
                                 node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.operand, newnode, assign_ctx))
+        newnode.postinit(self.visit(node.operand, newnode))
         return newnode
 
-    def visit_while(self, node, parent, assign_ctx=None):
+    def visit_while(self, node, parent):
         """visit a While node by returning a fresh instance of it"""
         newnode = nodes.While(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.test, newnode, assign_ctx),
-                         [self.visit(child, newnode, assign_ctx)
+        newnode.postinit(self.visit(node.test, newnode),
+                         [self.visit(child, newnode)
                           for child in node.body],
-                         [self.visit(child, newnode, assign_ctx)
+                         [self.visit(child, newnode)
                           for child in node.orelse])
         return newnode
 
-    def visit_with(self, node, parent, assign_ctx=None):
+    def visit_with(self, node, parent):
         newnode = nodes.With(node.lineno, node.col_offset, parent)
-        expr = self.visit(node.context_expr, newnode, assign_ctx)
+        expr = self.visit(node.context_expr, newnode)
         if node.optional_vars is not None:
-            optional_vars = self.visit(node.optional_vars, newnode, "Assign")
+            optional_vars = self.visit(node.optional_vars, newnode)
         else:
             optional_vars = None
         newnode.postinit([(expr, optional_vars)],
-                         [self.visit(child, newnode, None)
+                         [self.visit(child, newnode)
                           for child in node.body])
         return newnode
 
-    def visit_yield(self, node, parent, assign_ctx=None):
+    def visit_yield(self, node, parent):
         """visit a Yield node by returning a fresh instance of it"""
         newnode = nodes.Yield(node.lineno, node.col_offset, parent)
         if node.value is not None:
-            newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+            newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
 
 class TreeRebuilder3(TreeRebuilder):
     """extend and overwrite TreeRebuilder for python3k"""
 
-    def visit_arg(self, node, parent, assign_ctx=None):
+    def visit_arg(self, node, parent):
         """visit a arg node by returning a fresh AssName instance"""
         # TODO(cpopa): introduce an Arg node instead of using AssignName.
-        return self.visit_assignname(node, parent, assign_ctx, node.arg)
+        return self.visit_assignname(node, parent, node.arg)
 
-    def visit_nameconstant(self, node, parent, assign_ctx=None):
+    def visit_nameconstant(self, node, parent):
         # in Python 3.4 we have NameConstant for True / False / None
         return nodes.Const(node.value, getattr(node, 'lineno', None),
                            getattr(node, 'col_offset', None), parent)
 
-    def visit_excepthandler(self, node, parent, assign_ctx=None):
+    def visit_excepthandler(self, node, parent):
         """visit an ExceptHandler node by returning a fresh instance of it"""
         newnode = nodes.ExceptHandler(node.lineno, node.col_offset, parent)
         if node.name:
-            name = self.visit_assignname(node, newnode, assign_ctx, node.name)
+            name = self.visit_assignname(node, newnode, node.name)
         else:
             name = None
-        newnode.postinit(_visit_or_none(node, 'type', self, newnode, assign_ctx),
+        newnode.postinit(_visit_or_none(node, 'type', self, newnode),
                          name,
-                         [self.visit(child, newnode, assign_ctx)
+                         [self.visit(child, newnode)
                           for child in node.body])
         return newnode
 
-    def visit_nonlocal(self, node, parent, assign_ctx=None):
+    def visit_nonlocal(self, node, parent):
         """visit a Nonlocal node and return a new instance of it"""
         return nodes.Nonlocal(node.names, getattr(node, 'lineno', None),
                               getattr(node, 'col_offset', None), parent)
 
 
-    def visit_raise(self, node, parent, assign_ctx=None):
+    def visit_raise(self, node, parent):
         """visit a Raise node by returning a fresh instance of it"""
         newnode = nodes.Raise(node.lineno, node.col_offset, parent)
         # no traceback; anyway it is not used in Pylint
-        newnode.postinit(_visit_or_none(node, 'exc', self, newnode, assign_ctx),
-                         _visit_or_none(node, 'cause', self, newnode,
-                                        assign_ctx))
+        newnode.postinit(_visit_or_none(node, 'exc', self, newnode),
+                         _visit_or_none(node, 'cause', self, newnode))
         return newnode
 
-    def visit_starred(self, node, parent, assign_ctx=None):
+    def visit_starred(self, node, parent):
         """visit a Starred node and return a new instance of it"""
-        newnode = nodes.Starred(node.lineno, node.col_offset, parent)
-        newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+        context = _get_context(node)
+        newnode = nodes.Starred(ctx=context, lineno=node.lineno,
+                                col_offset=node.col_offset,
+                                parent=parent)
+        newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_try(self, node, parent, assign_ctx=None):
+    def visit_try(self, node, parent):
         # python 3.3 introduce a new Try node replacing
         # TryFinally/TryExcept nodes
         if node.finalbody:
             newnode = nodes.TryFinally(node.lineno, node.col_offset, parent)
             if node.handlers:
-                body = [self.visit_tryexcept(node, newnode, assign_ctx)]
+                body = [self.visit_tryexcept(node, newnode)]
             else:
-                body = [self.visit(child, newnode, assign_ctx)
+                body = [self.visit(child, newnode)
                         for child in node.body]
             newnode.postinit(body,
-                             [self.visit(n, newnode, assign_ctx)
+                             [self.visit(n, newnode)
                               for n in node.finalbody])
             return newnode
         elif node.handlers:
-            return self.visit_tryexcept(node, parent, assign_ctx)
+            return self.visit_tryexcept(node, parent)
 
-    def _visit_with(self, cls, node, parent, assign_ctx=None):
+    def _visit_with(self, cls, node, parent):
         if 'items' not in node._fields:
             # python < 3.3
-            return super(TreeRebuilder3, self).visit_with(node, parent,
-                                                          assign_ctx)
+            return super(TreeRebuilder3, self).visit_with(node, parent)
 
         newnode = cls(node.lineno, node.col_offset, parent)
         def visit_child(child):
-            expr = self.visit(child.context_expr, newnode, assign_ctx)
-            var = _visit_or_none(child, 'optional_vars', self, newnode,
-                                 'Assign')
+            expr = self.visit(child.context_expr, newnode)
+            var = _visit_or_none(child, 'optional_vars', self, newnode)
             return expr, var
         newnode.postinit([visit_child(child) for child in node.items],
-                         [self.visit(child, newnode, None)
+                         [self.visit(child, newnode)
                           for child in node.body])
         return newnode
 
-    def visit_with(self, node, parent, assign_ctx=None):
-        return self._visit_with(nodes.With, node, parent, assign_ctx=assign_ctx)
+    def visit_with(self, node, parent):
+        return self._visit_with(nodes.With, node, parent)
 
-    def visit_yieldfrom(self, node, parent, assign_ctx=None):
+    def visit_yieldfrom(self, node, parent):
         newnode = nodes.YieldFrom(node.lineno, node.col_offset, parent)
         if node.value is not None:
-            newnode.postinit(self.visit(node.value, newnode, assign_ctx))
+            newnode.postinit(self.visit(node.value, newnode))
         return newnode
 
-    def visit_classdef(self, node, parent, assign_ctx=None, newstyle=True):
+    def visit_classdef(self, node, parent, newstyle=True):
         return super(TreeRebuilder3, self).visit_classdef(node, parent,
-                                                          assign_ctx,
                                                           newstyle=newstyle)
 
     # Async structs added in Python 3.5
-    def visit_asyncfunctiondef(self, node, parent, assign_ctx=None):
-        return self._visit_functiondef(nodes.AsyncFunctionDef, node, parent,
-                                       assign_ctx=assign_ctx)
+    def visit_asyncfunctiondef(self, node, parent):
+        return self._visit_functiondef(nodes.AsyncFunctionDef, node, parent)
 
-    def visit_asyncfor(self, node, parent, assign_ctx=None):
-        return self._visit_for(nodes.AsyncFor, node, parent,
-                               assign_ctx=assign_ctx)
+    def visit_asyncfor(self, node, parent):
+        return self._visit_for(nodes.AsyncFor, node, parent)
 
-    def visit_await(self, node, parent, assign_ctx=None):
+    def visit_await(self, node, parent):
         newnode = nodes.Await(node.lineno, node.col_offset, parent)
-        newnode.postinit(value=self.visit(node.value, newnode, None))
+        newnode.postinit(value=self.visit(node.value, newnode))
         return newnode
 
-    def visit_asyncwith(self, node, parent, assign_ctx=None):
-        return self._visit_with(nodes.AsyncWith, node, parent,
-                                assign_ctx=assign_ctx)
+    def visit_asyncwith(self, node, parent):
+        return self._visit_with(nodes.AsyncWith, node, parent)
 
 
 if sys.version_info >= (3, 0):
diff --git a/astroid/tests/unittest_nodes.py b/astroid/tests/unittest_nodes.py
index 8abd85e..cf32ce9 100644
--- a/astroid/tests/unittest_nodes.py
+++ b/astroid/tests/unittest_nodes.py
@@ -25,6 +25,7 @@ import warnings
 
 import six
 
+import astroid
 from astroid import bases
 from astroid import builder
 from astroid import context as contextmod
@@ -757,5 +758,54 @@ class Python35AsyncTest(unittest.TestCase):
         self._test_await_async_as_string(code)
 
 
+class ContextTest(unittest.TestCase):
+
+    def test_subscript_load(self):
+        node = test_utils.extract_node('f[1]')
+        self.assertIs(node.ctx, astroid.Load)
+
+    def test_subscript_del(self):
+        node = test_utils.extract_node('del f[1]')
+        self.assertIs(node.targets[0].ctx, astroid.Del)
+
+    def test_subscript_store(self):
+        node = test_utils.extract_node('f[1] = 2')
+        subscript = node.targets[0]
+        self.assertIs(subscript.ctx, astroid.Store)
+
+    def test_list_load(self):
+        node = test_utils.extract_node('[]')
+        self.assertIs(node.ctx, astroid.Load)
+
+    def test_list_del(self):
+        node = test_utils.extract_node('del []')
+        self.assertIs(node.targets[0].ctx, astroid.Del)
+
+    def test_list_store(self):
+        with self.assertRaises(exceptions.AstroidSyntaxError):
+            test_utils.extract_node('[0] = 2')
+
+    def test_tuple_load(self):
+        node = test_utils.extract_node('(1, )')
+        self.assertIs(node.ctx, astroid.Load)
+
+    def test_tuple_store(self):
+        with self.assertRaises(exceptions.AstroidSyntaxError):
+            test_utils.extract_node('(1, ) = 3')
+
+    @test_utils.require_version(minver='3.5')
+    def test_starred_load(self):
+        node = test_utils.extract_node('a = *b')
+        starred = node.value
+        self.assertIs(starred.ctx, astroid.Load)
+
+    @test_utils.require_version(minver='3.0')
+    def test_starred_store(self):
+        node = test_utils.extract_node('a, *b = 1, 2')
+        starred = node.targets[0].elts[1]
+        self.assertIs(starred.ctx, astroid.Store) 
+        
+        
+
 if __name__ == '__main__':
     unittest.main()