feat: list indexing using STC methods (pyccel#1926)

Add support for indexing a list in C. This PR fixes pyccel#1876 . Further it
allows the declarations to be tested properly

---------

Co-authored-by: EmilyBourne <[email protected]>

Author: Farouk-Echaref

CHANGELOG.md

@@ -16,12 +16,13 @@ All notable changes to this project will be documented in this file.
 -   #1750 : Add Python support for set method `remove()`.
 -   #1743 : Add Python support for set method `discard()`.
 -   #1754 : Add Python support for set method `update()`.
+-   #1893 : Add Python support for set initialisation with `set()`.
 -   #1787 : Ensure STC is installed with Pyccel.
 -   #1656 : Ensure gFTL is installed with Pyccel.
 -   #1844 : Add line numbers and code to errors from built-in function calls.
 -   #1655 : Add the appropriate C language equivalent for declaring a Python `list` container using the STC library.
+-   #1876 : Add C support for indexing lists.
 -   #1659 : Add the appropriate C language equivalent for declaring a Python `set` container using the STC library.
--   #1893 : Add Python support for set initialisation with `set()`.
 -   #1877 : Add C Support for set method `pop()`.
 -   #1895 : Add Python support for dict initialisation with `{}`.
 -   #1895 : Add Python support for dict initialisation with `dict()`.

docs/builtin-functions.md

@@ -74,6 +74,25 @@ Python contains a limited number of builtin functions defined [here](https://doc
 | **`zip`** | as a loop iterable |
 | \_\_`import`\_\_ | No
 
+## List methods
+
+| Method | Supported |
+|----------|-----------|
+| `append` | Python-only |
+| `clear` | Python-only |
+| `copy` | Python-only |
+| `count` | No |
+| `extend` | Python-only |
+| `index` | No |
+| `insert` | Python-only |
+| `max` | No |
+| `min` | No |
+| `pop` | Python-only |
+| `remove` | Python-only |
+| `reverse` | No |
+| `sort` | Python-only |
+
+
 ## Dictionary methods
 
 :warning: The dictionary support provided by Pyccel only covers unordered dictionaries.

pyccel/codegen/printing/ccode.py

@@ -1472,16 +1472,9 @@ def _print_IndexedElement(self, expr):
         inds = list(expr.indices)
         base_shape = base.shape
         allow_negative_indexes = expr.allows_negative_indexes
-        if isinstance(base.class_type, NumpyNDArrayType):
-            #set dtype to the C struct types
-            dtype = self.find_in_ndarray_type_registry(expr.dtype)
-        elif isinstance(base.class_type, HomogeneousContainerType):
-            dtype = self.find_in_ndarray_type_registry(numpy_precision_map[(expr.dtype.primitive_type, expr.dtype.precision)])
-        else:
-            raise NotImplementedError(f"Don't know how to index {expr.class_type} type")
 
         if isinstance(base, IndexedElement):
-            while isinstance(base, IndexedElement) and isinstance(base.class_type, HomogeneousContainerType):
+            while isinstance(base, IndexedElement) and isinstance(base.class_type, (NumpyNDArrayType, HomogeneousTupleType)):
                 inds = list(base.indices) + inds
                 base = base.base
 
@@ -1497,7 +1490,27 @@ def _print_IndexedElement(self, expr):
                     inds[i] = IfTernaryOperator(PyccelLt(ind, LiteralInteger(0)),
                         PyccelAdd(base_shape[i], ind, simplify = True), ind)
 
+        if isinstance(base.class_type, HomogeneousListType):
+            assign = expr.get_user_nodes(Assign)
+            index = self._print(inds[0])
+            list_var = self._print(ObjectAddress(base))
+            container_type = self.get_c_type(base.class_type)
+            if assign:
+                assert len(assign) == 1
+                assign_node = assign[0]
+                lhs = assign_node.lhs
+                if lhs == expr or lhs.is_user_of(expr):
+                    return f"(*{container_type}_at_mut({list_var},{index}))"
+            return f"(*{container_type}_at({list_var},{index}))"
+
         base_name = self._print(base)
+        if isinstance(base.class_type, NumpyNDArrayType):
+            #set dtype to the C struct types
+            dtype = self.find_in_ndarray_type_registry(expr.dtype)
+        elif isinstance(base.class_type, HomogeneousTupleType):
+            dtype = self.find_in_ndarray_type_registry(numpy_precision_map[(expr.dtype.primitive_type, expr.dtype.precision)])
+        else:
+            raise NotImplementedError(f"Don't know how to index {expr.class_type} type")
         if expr.rank > 0:
             #managing the Slice input
             for i , ind in enumerate(inds):

tests/epyccel/test_epyccel_decorators.py

@@ -169,3 +169,22 @@ def my_sum(v: 'T[:]'):
 
     assert python_cmplx == pyccel_cmplx
     assert isinstance(python_cmplx, type(pyccel_cmplx))
+
+@pytest.mark.parametrize("language", (
+        pytest.param("fortran", marks = [
+            pytest.mark.skip(reason="lists not implemented in fortran"),
+            pytest.mark.fortran]),
+        pytest.param("c", marks = pytest.mark.c),
+        pytest.param("python", marks = pytest.mark.python)
+        )
+)
+def test_allow_negative_index_list(language):
+    def allow_negative_index_annotation():
+        a = [1,2,3,4]
+        return a[-1], a[-2], a[-3], a[0]
+
+    epyc_allow_negative_index_annotation = epyccel(allow_negative_index_annotation, language=language)
+
+    assert epyc_allow_negative_index_annotation() == allow_negative_index_annotation()
+    assert isinstance(epyc_allow_negative_index_annotation(), type(allow_negative_index_annotation()))
+

tests/epyccel/test_epyccel_lists.py

@@ -17,6 +17,18 @@
 def language(request):
     return request.param
 
+@pytest.fixture( params=[
+        pytest.param("c", marks = pytest.mark.c),
+        pytest.param("fortran", marks = [
+            pytest.mark.skip(reason="lists not implemented in fortran"),
+            pytest.mark.fortran]),
+        pytest.param("python", marks = pytest.mark.python)
+    ],
+    scope = "module"
+)
+def stc_language(request):
+    return request.param
+
 def test_pop_last_element(language) :
     def pop_last_element():
         a = [1,3,45]
@@ -658,3 +670,23 @@ def g():
     epyc_f = epyccel(f, language=language)
     assert f() == epyc_f()
 
+def test_mutable_indexing(stc_language):
+    def f():
+        a = [1,2,3,4]
+        a[0] = 5
+        a[2] += 6
+        return a[0], a[1], a[2], a[3]
+
+    epyc_f = epyccel(f, language=stc_language)
+    assert f() == epyc_f()
+
+def test_mutable_multi_level_indexing(stc_language):
+    def f():
+        a = [1,2,3,4]
+        b = [a]
+        b[0][0] = 5
+        b[0][2] = 6
+        return a[0], a[1], a[2], a[3]
+
+    epyc_f = epyccel(f, language=stc_language)
+    assert f() == epyc_f()

tests/epyccel/test_epyccel_variable_annotations.py

@@ -229,13 +229,15 @@ def test_homogeneous_list_annotation_int(stc_language):
     def homogeneous_list_annotation():
         a: 'list[int]'  # pylint: disable=unused-variable
         a = [1, 2, 3, 4]
+        return a[0], a[1], a[2], a[3]
     epyc_homogeneous_list_annotation = epyccel(homogeneous_list_annotation, language=stc_language)
     assert epyc_homogeneous_list_annotation() == homogeneous_list_annotation()
     assert isinstance(epyc_homogeneous_list_annotation(), type(homogeneous_list_annotation()))
 
 def test_homogeneous_list_without_annotation(stc_language):
     def homogeneous_list():
         a = [1, 2, 3, 4] # pylint: disable=unused-variable
+        return a[0], a[1], a[2], a[3]
     epyc_homogeneous_list = epyccel(homogeneous_list, language=stc_language)
     assert epyc_homogeneous_list() == homogeneous_list()
     assert isinstance(epyc_homogeneous_list(), type(homogeneous_list()))
@@ -244,6 +246,7 @@ def test_homogeneous_list_annotation_float(stc_language):
     def homogeneous_list_annotation():
         a: 'list[float]'  # pylint: disable=unused-variable
         a = [1.1, 2.2, 3.3, 4.4]
+        return a[0], a[1], a[2], a[3]
     epyc_homogeneous_list_annotation = epyccel(homogeneous_list_annotation, language=stc_language)
     assert epyc_homogeneous_list_annotation() == homogeneous_list_annotation()
     assert isinstance(epyc_homogeneous_list_annotation(), type(homogeneous_list_annotation()))
@@ -252,6 +255,7 @@ def test_homogeneous_list_annotation_bool(stc_language):
     def homogeneous_list_annotation():
         a: 'list[bool]'  # pylint: disable=unused-variable
         a = [False, True, True, False]
+        return a[0], a[1], a[2], a[3]
     epyc_homogeneous_list_annotation = epyccel(homogeneous_list_annotation, language=stc_language)
     assert epyc_homogeneous_list_annotation() == homogeneous_list_annotation()
     assert isinstance(epyc_homogeneous_list_annotation(), type(homogeneous_list_annotation()))
@@ -260,6 +264,7 @@ def test_homogeneous_list_annotation_complex(stc_language):
     def homogeneous_list_annotation():
         a: 'list[complex]'  # pylint: disable=unused-variable
         a = [1+1j, 2+2j, 3+3j, 4+4j]
+        return a[0], a[1], a[2], a[3]
     epyc_homogeneous_list_annotation = epyccel(homogeneous_list_annotation, language=stc_language)
     assert epyc_homogeneous_list_annotation() == homogeneous_list_annotation()
     assert isinstance(epyc_homogeneous_list_annotation(), type(homogeneous_list_annotation()))
@@ -268,6 +273,7 @@ def test_homogeneous_list_annotation_embedded_complex(stc_language):
     def homogeneous_list_annotation():
         a : 'list[complex]' = [1j, 2j]
         b = [a] # pylint: disable=unused-variable
+        return b[0][0]
     epyc_homogeneous_list_annotation = epyccel(homogeneous_list_annotation, language=stc_language)
     assert epyc_homogeneous_list_annotation() == homogeneous_list_annotation()
     assert isinstance(epyc_homogeneous_list_annotation(), type(homogeneous_list_annotation()))

tests/epyccel/test_functionals.py

@@ -10,7 +10,7 @@
 @pytest.fixture( params=[
         pytest.param("fortran", marks = pytest.mark.fortran),
         pytest.param("c", marks = [
-            pytest.mark.xfail(reason="C does not support list indexing yet, related issue #1876"),
+            pytest.mark.skip(reason="C does not support list comprehensions. See #1948"),
             pytest.mark.c]),
         pytest.param("python", marks = pytest.mark.python)
     ],