fixed list function implementation (pyccel#1898)

Fix list() issue mentioned in
pyccel#1892 . This PR fixes the list()
implementation when using a list or a tuple as a parameter

Commit Summary
- Created PythonListFunction class which acts as a wrapper for
PythonList and handles such cases.
- Created unit tests using the newly implemented class.

---------

Co-authored-by: Emily Bourne <[email protected]>

Author: shoaib-moeen

AUTHORS

@@ -32,3 +32,4 @@ Contributors
 * Mustapha Belbiad
 * Varadarajan Rengaraj
 * Said Mazouz
+* Shoaib Moeen

CHANGELOG.md

@@ -54,6 +54,7 @@ All notable changes to this project will be documented in this file.
 -   #1933 : Improve code printing speed.
 -   #1930 : Preserve ordering of import targets.
 -   #1951 : Fix return type for class whose argument cannot be wrapped.
+-   #1892 : Fix implementation of list function when an iterable is passed as parameter.
 
 ### Changed
 

pyccel/ast/builtins.py

@@ -46,6 +46,7 @@
     'PythonInt',
     'PythonLen',
     'PythonList',
+    'PythonListFunction',
     'PythonMap',
     'PythonMax',
     'PythonMin',
@@ -719,6 +720,47 @@ def is_homogeneous(self):
         """
         return True
 
+
+class PythonListFunction(PyccelFunction):
+    """
+    Class representing a call to the `list` function.
+
+    Class representing a call to the `list` function. This is
+    different to the `[,]' syntax as it only takes one argument
+    and unpacks any variables.
+
+    Parameters
+    ----------
+    arg : TypedAstNode
+        The argument passed to the function call.
+    """
+    name = 'list'
+    __slots__ = ('_class_type', '_shape')
+    _attribute_nodes = ()
+
+    def __new__(cls, arg):
+        if isinstance(arg, PythonList):
+            return arg
+        elif isinstance(arg.shape[0], LiteralInteger):
+            return PythonList(*[arg[i] for i in range(arg.shape[0])])
+        else:
+            return super().__new__(cls)
+
+    def __init__(self, copied_obj):
+        self._class_type = copied_obj.class_type
+        self._shape = copied_obj.shape
+        super().__init__(copied_obj)
+
+    @property
+    def copied_obj(self):
+        """
+        The object being copied.
+
+        The object being copied to create a new list instance.
+        """
+        return self._args[0]
+
+
 #==============================================================================
 class PythonSet(TypedAstNode):
     """
@@ -1382,7 +1424,7 @@ def print_string(self):
     'float'    : PythonFloat,
     'int'      : PythonInt,
     'len'      : PythonLen,
-    'list'     : PythonList,
+    'list'     : PythonListFunction,
     'map'      : PythonMap,
     'max'      : PythonMax,
     'min'      : PythonMin,

pyccel/parser/semantic.py

@@ -22,7 +22,7 @@
 from pyccel.ast.basic         import PyccelAstNode, TypedAstNode, ScopedAstNode
 
 from pyccel.ast.builtins import PythonPrint, PythonTupleFunction, PythonSetFunction
-from pyccel.ast.builtins import PythonComplex, PythonDict, PythonDictFunction
+from pyccel.ast.builtins import PythonComplex, PythonDict, PythonDictFunction, PythonListFunction
 from pyccel.ast.builtins import builtin_functions_dict, PythonImag, PythonReal
 from pyccel.ast.builtins import PythonList, PythonConjugate , PythonSet
 from pyccel.ast.builtins import (PythonRange, PythonZip, PythonEnumerate,
@@ -148,7 +148,7 @@
 
 type_container = {
                    PythonTupleFunction : HomogeneousTupleType,
-                   PythonList : HomogeneousListType,
+                   PythonListFunction : HomogeneousListType,
                    PythonSetFunction : HomogeneousSetType,
                   }
 
@@ -1969,7 +1969,7 @@ def _get_indexed_type(self, base, args, expr):
             if (len(args) == 2 and args[1] is LiteralEllipsis()) or len(args) == 1:
                 syntactic_annotation = self._convert_syntactic_object_to_type_annotation(args[0])
                 internal_datatypes = self._visit(syntactic_annotation)
-                if dtype_cls in type_container :
+                if dtype_cls in type_container:
                     class_type = type_container[dtype_cls]
                 else:
                     raise errors.report(f"Unknown annotation base {base}\n"+PYCCEL_RESTRICTION_TODO,

tests/epyccel/test_epyccel_lists.py

@@ -690,3 +690,70 @@ def f():
 
     epyc_f = epyccel(f, language=stc_language)
     assert f() == epyc_f()
+
+def test_homogenous_list_int_copy(language):
+    def homogeneous_list_int():
+        return list([1, 2, 3, 4])
+    f1 = homogeneous_list_int
+    f2 = epyccel( f1 , language=language)
+
+    python_out = f1()
+    pyccel_out = f2()
+    print(pyccel_out)
+    print(python_out)
+
+    assert python_out == pyccel_out
+
+def test_homogenous_list_bool_copy(language):
+    def homogeneous_list_bool():
+        return list([True, False, True, False])
+    f1 = homogeneous_list_bool
+    f2 = epyccel( f1 , language=language)
+
+    python_out = f1()
+    pyccel_out = f2()
+    print(pyccel_out)
+    print(python_out)
+
+    assert python_out == pyccel_out
+
+def test_homogenous_list_float_copy(language):
+    def homogeneous_list_float():
+        return list([1.0, 2.0, 3.0, 4.0])
+    f1 = homogeneous_list_float
+    f2 = epyccel( f1 , language=language)
+
+    python_out = f1()
+    pyccel_out = f2()
+    print(pyccel_out)
+    print(python_out)
+
+    assert python_out == pyccel_out
+
+def test_homogenous_list_int_tuple_copy(language):
+    def homogeneous_list_int_tuple():
+        return list((1, 2, 3, 4))
+    f1 = homogeneous_list_int_tuple
+    f2 = epyccel( f1 , language=language)
+
+    python_out = f1()
+    pyccel_out = f2()
+    print(pyccel_out)
+    print(python_out)
+
+    assert python_out == pyccel_out
+
+def test_homogenous_list_unknown_size_copy(language):
+    def homogeneous_list_unknown_size_copy(n : int):
+        a = (3,)*n
+        b = list(a)
+        return b[0]
+    f1 = homogeneous_list_unknown_size_copy
+    f2 = epyccel( f1 , language=language)
+
+    python_out = f1(5)
+    pyccel_out = f2(5)
+    print(pyccel_out)
+    print(python_out)
+
+    assert python_out == pyccel_out