implement slicing for __getitem__ with interpreter

jedi/evaluate/compiled/__init__.py

@@ -99,17 +99,17 @@ class CompiledObject(Base):
         self.obj.__getitem__
 
         result = []
-        from jedi.evaluate import iterable
         for typ in index_types:
-            if isinstance(typ, iterable.Slice):
-                result.append(self)
+            index = None
+            try:
+                index = typ.obj
+                new = self.obj[index]
+            except (KeyError, IndexError, TypeError, AttributeError):
+                # Just try, we don't care if it fails, except for slices.
+                if isinstance(index, slice):
+                    result.append(self)
             else:
-                try:
-                    new = self.obj[typ.obj]
-                except (KeyError, IndexError, TypeError, AttributeError):
-                    pass  # just try, we don't care if it fails.
-                else:
-                    result.append(CompiledObject(new))
+                result.append(CompiledObject(new))
         if not result:
             try:
                 for obj in self.obj:

jedi/evaluate/iterable.py

@@ -425,17 +425,30 @@ class Slice(object):
         self._stop = stop
         self._step = step
 
-    def start(self):
-        return self._result(self._start)
+    @property
+    def obj(self):
+        """
+        Imitate CompiledObject.obj behavior and return a ``builtin.slice()``
+        object.
+        """
+        def get(element):
+            if element is None:
+                return None
 
-    def stop(self):
-        return self._result(self._stop)
+            result = self._evaluator.process_precedence_element(element)
+            if len(result) != 1:
+                # We want slices to be clear defined with just one type.
+                # Otherwise we will return an empty slice object.
+                raise IndexError
+            try:
+                return result[0].obj
+            except AttributeError:
+                return None
 
-    def step(self):
-        return self._result(self._step)
-
-    def _result(self, element):
-        return self._evaluator.process_precedence_element(element)
+        try:
+            return slice(get(self._start), get(self._stop), get(self._step))
+        except IndexError:
+            return slice(None, None, None)
 
 
 def create_indexes_or_slices(evaluator, index_array):

test/test_api/test_interpreter.py

@@ -63,3 +63,11 @@ class TestInterpreterAPI(TestCase):
         self.check_interpreter_complete('array[2].upper',
                                         locals(),
                                         ['upper'])
+
+    def test_slice(self):
+        class Foo():
+            bar = []
+        baz = 'xbarx'
+        self.check_interpreter_complete('getattr(Foo, baz[1:-1]).append',
+                                        locals(),
+                                        ['append'])