Support dict variable declarations in C (pyccel#1943)

Add C support for `dict` initialisation and freeing in C. Fixes pyccel#1942

Author: EmilyBourne

CHANGELOG.md

@@ -26,6 +26,7 @@ All notable changes to this project will be documented in this file.
 -   #1895 : Add Python support for dict initialisation with `{}`.
 -   #1895 : Add Python support for dict initialisation with `dict()`.
 -   #1886 : Add Python support for dict method `pop()`.
+-   #1944 : Add the appropriate C language equivalent for declaring a Python `dict` container using the STC library.
 -   #1936 : Add missing C output for inline decorator example in documentation
 -   #1937 : Optimise `pyccel.ast.basic.PyccelAstNode.substitute` method.
 -   \[INTERNALS\] Added `container_rank` property to `ast.datatypes.PyccelType` objects.

docs/builtin-functions.md

@@ -19,7 +19,7 @@ Python contains a limited number of builtin functions defined [here](https://doc
 | `compile` | No |
 | **`complex`** | **Yes** |
 | `delattr` | No |
-| *`dict`* | Preliminary Python support |
+| *`dict`* | Preliminary Python and C **unordered** support |
 | `dir` | No |
 | `divmod` | No |
 | **`enumerate`** | as a loop iterable |
@@ -76,6 +76,8 @@ Python contains a limited number of builtin functions defined [here](https://doc
 
 ## Dictionary methods
 
+:warning: The dictionary support provided by Pyccel only covers unordered dictionaries.
+
 | Method | Supported |
 |----------|-----------|
 | `clear` | No |

pyccel/codegen/printing/ccode.py

@@ -11,7 +11,7 @@
 
 from pyccel.ast.builtins  import PythonRange, PythonComplex
 from pyccel.ast.builtins  import PythonPrint, PythonType
-from pyccel.ast.builtins  import PythonList, PythonTuple, PythonSet
+from pyccel.ast.builtins  import PythonList, PythonTuple, PythonSet, PythonDict
 
 from pyccel.ast.core      import Declare, For, CodeBlock
 from pyccel.ast.core      import FuncAddressDeclare, FunctionCall, FunctionCallArgument
@@ -29,7 +29,7 @@
 from pyccel.ast.datatypes import TupleType, FixedSizeNumericType
 from pyccel.ast.datatypes import CustomDataType, StringType, HomogeneousTupleType, HomogeneousListType, HomogeneousSetType
 from pyccel.ast.datatypes import PrimitiveBooleanType, PrimitiveIntegerType, PrimitiveFloatingPointType, PrimitiveComplexType
-from pyccel.ast.datatypes import HomogeneousContainerType
+from pyccel.ast.datatypes import HomogeneousContainerType, DictType
 
 from pyccel.ast.internals import Slice, PrecomputedCode, PyccelArrayShapeElement
 
@@ -678,8 +678,13 @@ def init_stc_container(self, expr, assignment_var):
             The generated C code for the container initialization.
         """
 
-        dtype = self.get_c_type(assignment_var.lhs.class_type)
-        keyraw = '{' + ', '.join(self._print(a) for a in expr.args) + '}'
+        class_type = assignment_var.lhs.class_type
+        dtype = self.get_c_type(class_type)
+        if isinstance(expr, PythonDict):
+            dict_item_strs = [(self._print(k), self._print(v)) for k,v in zip(expr.keys, expr.values)]
+            keyraw = '{' + ', '.join(f'{{{k}, {v}}}' for k,v in dict_item_strs) + '}'
+        else:
+            keyraw = '{' + ', '.join(self._print(a) for a in expr.args) + '}'
         container_name = self._print(assignment_var.lhs)
         init = f'{container_name} = c_init({dtype}, {keyraw});\n'
         return init
@@ -1013,15 +1018,22 @@ def _print_Import(self, expr):
             for t in expr.target:
                 dtype = t.object.class_type
                 container_type = t.target
-                container_key = self.get_c_type(dtype.element_type)
+                if isinstance(dtype, DictType):
+                    container_key_key = self.get_c_type(dtype.key_type)
+                    container_val_key = self.get_c_type(dtype.value_type)
+                    container_key = f'{container_key_key}_{container_val_key}'
+                    element_decl = f'#define i_key {container_key_key}\n#define i_val {container_val_key}\n'
+                else:
+                    container_key = self.get_c_type(dtype.element_type)
+                    element_decl = f'#define i_key {container_key}\n'
                 header_guard_prefix = import_header_guard_prefix.get(source, '')
                 header_guard = f'{header_guard_prefix}_{container_type.upper()}'
-                code += (f'#ifndef {header_guard}\n'
-                        f'#define {header_guard}\n'
-                        f'#define i_type {container_type}\n'
-                        f'#define i_key {container_key}\n'
-                        f'#include <{source}.h>\n'
-                        f'#endif // {header_guard}\n\n')
+                code += ''.join((f'#ifndef {header_guard}\n',
+                        f'#define {header_guard}\n',
+                        f'#define i_type {container_type}\n',
+                        element_decl,
+                        f'#include <{source}.h>\n',
+                        f'#endif // {header_guard}\n\n'))
             return code
         # Get with a default value is not used here as it is
         # slower and on most occasions the import will not be in the
@@ -1245,6 +1257,13 @@ def get_c_type(self, dtype):
             i_type = f'{container_type}_{element_type}'
             self.add_import(Import(f'stc/{container_type}', AsName(VariableTypeAnnotation(dtype), i_type)))
             return i_type
+        elif isinstance(dtype, DictType):
+            container_type = 'hmap'
+            key_type = self.get_c_type(dtype.key_type).replace(' ', '_')
+            val_type = self.get_c_type(dtype.value_type).replace(' ', '_')
+            i_type = f'{container_type}_{key_type}_{val_type}'
+            self.add_import(Import(f'stc/{container_type}', AsName(VariableTypeAnnotation(dtype), i_type)))
+            return i_type
         else:
             key = dtype
 
@@ -1320,7 +1339,7 @@ def get_declare_type(self, expr):
         rank  = expr.rank
 
         if rank > 0:
-            if isinstance(expr.class_type, (HomogeneousSetType, HomogeneousListType)):
+            if isinstance(expr.class_type, (HomogeneousSetType, HomogeneousListType, DictType)):
                 dtype = self.get_c_type(expr.class_type)
                 return dtype
             if isinstance(expr.class_type,(HomogeneousTupleType, NumpyNDArrayType)):
@@ -1610,7 +1629,7 @@ def _print_PyccelArrayShapeElement(self, expr):
     def _print_Allocate(self, expr):
         free_code = ''
         variable = expr.variable
-        if isinstance(variable.class_type, (HomogeneousListType, HomogeneousSetType)):
+        if isinstance(variable.class_type, (HomogeneousListType, HomogeneousSetType, DictType)):
             return ''
         if variable.rank > 0:
             #free the array if its already allocated and checking if its not null if the status is unknown
@@ -1646,7 +1665,7 @@ def _print_Allocate(self, expr):
             raise NotImplementedError(f"Allocate not implemented for {variable}")
 
     def _print_Deallocate(self, expr):
-        if isinstance(expr.variable.class_type, (HomogeneousListType, HomogeneousSetType)):
+        if isinstance(expr.variable.class_type, (HomogeneousListType, HomogeneousSetType, DictType)):
             variable_address = self._print(ObjectAddress(expr.variable))
             container_type = self.get_c_type(expr.variable.class_type)
             return f'{container_type}_drop({variable_address});\n'
@@ -2196,7 +2215,7 @@ def _print_Assign(self, expr):
         if isinstance(rhs, (NumpyFull)):
             return prefix_code+self.arrayFill(expr)
         lhs = self._print(expr.lhs)
-        if isinstance(rhs, (PythonList, PythonSet)):
+        if isinstance(rhs, (PythonList, PythonSet, PythonDict)):
             return prefix_code+self.init_stc_container(rhs, expr)
         rhs = self._print(expr.rhs)
         return prefix_code+'{} = {};\n'.format(lhs, rhs)

tests/epyccel/test_epyccel_variable_annotations.py

@@ -7,7 +7,7 @@
 import pytest
 
 from pyccel import epyccel
-from pyccel.errors.errors import PyccelSemanticError, Errors
+from pyccel.errors.errors import PyccelSemanticError
 from pyccel.decorators import allow_negative_index, stack_array
 
 @pytest.fixture( params=[
@@ -272,17 +272,22 @@ def homogeneous_list_annotation():
     assert epyc_homogeneous_list_annotation() == homogeneous_list_annotation()
     assert isinstance(epyc_homogeneous_list_annotation(), type(homogeneous_list_annotation()))
 
-@pytest.mark.parametrize('lang',
-        [pytest.param("python", marks = pytest.mark.python)])
-def test_dict_empty_init(lang):
-    def dict_empty_init():
+def test_dict_int_float(stc_language):
+    def dict_int_float():
         # Not valid in Python 3.8
-        a : dict[int, float] #pylint: disable=unsubscriptable-object
+        a : dict[int, float] #pylint: disable=unsubscriptable-object,unused-variable
         a = {1:1.0, 2:2.0}
-        return a
 
-    epyc_dict_empty_init = epyccel(dict_empty_init, language = lang)
-    pyccel_result = epyc_dict_empty_init()
-    python_result = dict_empty_init()
-    assert isinstance(python_result, type(pyccel_result))
-    assert python_result == pyccel_result
+    epyc_dict_int_float = epyccel(dict_int_float, language = stc_language)
+    epyc_dict_int_float()
+    dict_int_float()
+
+def test_dict_empty_init(stc_language):
+    def dict_empty_init():
+        # Not valid in Python 3.8
+        a : dict[int, float] #pylint: disable=unsubscriptable-object,unused-variable
+        a = {}
+
+    epyc_dict_empty_init = epyccel(dict_empty_init, language = stc_language)
+    epyc_dict_empty_init()
+    dict_empty_init()