[DICT] Add Python support for dict initialisation (pyccel#1896)

Add support for the initialisation of a dictionary via a call to `{}`.
Syntactic, semantic and Python printing support is added. The `DictType`
datatype is expanded to match the expected description from the docs.
Fixes pyccel#1895

Author: EmilyBourne

CHANGELOG.md

@@ -23,6 +23,7 @@ All notable changes to this project will be documented in this file.
 -   #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 `{}`.
 -   \[INTERNALS\] Added `container_rank` property to `ast.datatypes.PyccelType` objects.
 -   \[DEVELOPER\] Added an improved traceback to the developer-mode errors for errors in function calls.
 

ci_tools/check_pylint_commands.py

@@ -20,7 +20,8 @@
                             re.compile('tests/codegen/fcode/scripts/precision.py'):['unused-variable'],
                             re.compile('tests/semantic/scripts/expressions.py'):['unused-variable'],
                             re.compile('tests/semantic/scripts/calls.py'):['unused-variable'],
-                            re.compile('tests/pyccel/project_class_imports/.*'):['relative-beyond-top-level'] # ignore Codacy bad pylint call
+                            re.compile('tests/pyccel/project_class_imports/.*'):['relative-beyond-top-level'], # ignore Codacy bad pylint call
+                            re.compile('tests/errors/syntax_errors/import_star.py'):['wildcard-import']
                            }
 
 def run_pylint(file, flag, messages):

pyccel/ast/builtins.py

@@ -20,6 +20,7 @@
 from .datatypes import HomogeneousTupleType, InhomogeneousTupleType
 from .datatypes import HomogeneousListType, HomogeneousContainerType
 from .datatypes import FixedSizeNumericType, HomogeneousSetType, SymbolicType
+from .datatypes import DictType
 from .internals import PyccelFunction, Slice, PyccelArrayShapeElement
 from .literals  import LiteralInteger, LiteralFloat, LiteralComplex, Nil
 from .literals  import Literal, LiteralImaginaryUnit, convert_to_literal
@@ -37,6 +38,7 @@
     'PythonComplex',
     'PythonComplexProperty',
     'PythonConjugate',
+    'PythonDict',
     'PythonEnumerate',
     'PythonFloat',
     'PythonImag',
@@ -805,6 +807,81 @@ def __init__(self, copied_obj):
         self._shape = copied_obj.shape
         super().__init__(copied_obj)
 
+#==============================================================================
+class PythonDict(PyccelFunction):
+    """
+    Class representing a call to Python's `{}` function.
+
+    Class representing a call to Python's `{}` function which generates a
+    literal Python dict. This operator does not handle `**a` expressions.
+
+    Parameters
+    ----------
+    keys : iterable[TypedAstNode]
+        The keys of the new dictionary.
+    values : iterable[TypedAstNode]
+        The values of the new dictionary.
+    """
+    __slots__ = ('_keys', '_values', '_shape', '_class_type')
+    _attribute_nodes = ('_keys', '_values')
+    _rank = 1
+
+    def __init__(self, keys, values):
+        self._keys = keys
+        self._values = values
+        super().__init__()
+        if pyccel_stage == 'syntactic':
+            return
+        elif len(keys) != len(values):
+            raise TypeError("Unpacking values in a dictionary is not yet supported.")
+        elif len(keys) == 0:
+            self._shape = (LiteralInteger(0),)
+            self._class_type = DictType(GenericType(), GenericType())
+            return
+
+        key0 = keys[0]
+        val0 = values[0]
+        homogeneous_keys = all(k.class_type is not GenericType() for k in keys) and \
+                           all(key0.class_type == k.class_type for k in keys[1:])
+        homogeneous_vals = all(v.class_type is not GenericType() for v in values) and \
+                           all(val0.class_type == v.class_type for v in values[1:])
+
+        if homogeneous_keys and homogeneous_vals:
+            self._class_type = DictType(key0.class_type, val0.class_type)
+
+            self._shape = (LiteralInteger(len(keys)), )
+        else:
+            raise TypeError("Can't create an inhomogeneous dict")
+
+    def __iter__(self):
+        return zip(self._keys, self._values)
+
+    def __str__(self):
+        args = ', '.join(f'{k}: {v}' for k,v in self)
+        return f'{{{args}}}'
+
+    def __repr__(self):
+        args = ', '.join(f'{repr(k)}: {repr(v)}' for k,v in self)
+        return f'PythonDict({args})'
+
+    @property
+    def keys(self):
+        """
+        The keys of the new dictionary.
+
+        The keys of the new dictionary.
+        """
+        return self._keys
+
+    @property
+    def values(self):
+        """
+        The values of the new dictionary.
+
+        The values of the new dictionary.
+        """
+        return self._values
+
 #==============================================================================
 class PythonMap(PyccelFunction):
     """

pyccel/ast/class_defs.py

@@ -15,24 +15,25 @@
 from .core       import ClassDef, PyccelFunctionDef
 from .datatypes  import (PythonNativeBool, PythonNativeInt, PythonNativeFloat,
                          PythonNativeComplex, StringType, TupleType, CustomDataType,
-                         HomogeneousListType, HomogeneousSetType)
+                         HomogeneousListType, HomogeneousSetType, DictType)
 from .numpyext   import (NumpyShape, NumpySum, NumpyAmin, NumpyAmax,
                          NumpyImag, NumpyReal, NumpyTranspose,
                          NumpyConjugate, NumpySize, NumpyResultType, NumpyArray)
 from .numpytypes import NumpyNumericType, NumpyNDArrayType
 
 __all__ = (
     'BooleanClass',
-    'IntegerClass',
-    'FloatClass',
     'ComplexClass',
+    'DictClass',
+    'FloatClass',
+    'IntegerClass',
+    'ListClass',
+    'NumpyArrayClass',
     'SetClass',
     'StringClass',
-    'NumpyArrayClass',
     'TupleClass',
-    'ListClass',
-    'literal_classes',
     'get_cls_base',
+    'literal_classes',
 )
 
 #=======================================================================================
@@ -166,6 +167,12 @@
 
 #=======================================================================================
 
+DictClass = ClassDef('dict',
+        methods=[
+        ])
+
+#=======================================================================================
+
 TupleClass = ClassDef('tuple',
         methods=[
             #index
@@ -254,6 +261,8 @@ def get_cls_base(class_type):
         return ListClass
     elif isinstance(class_type, HomogeneousSetType):
         return SetClass
+    elif isinstance(class_type, DictType):
+        return DictClass
     else:
         raise NotImplementedError(f"No class definition found for type {class_type}")
 

pyccel/ast/datatypes.py

@@ -977,23 +977,23 @@ class DictType(ContainerType, metaclass = ArgumentSingleton):
 
     Parameters
     ----------
-    index_type : PyccelType
+    key_type : PyccelType
         The type of the keys of the homogeneous dictionary.
     value_type : PyccelType
         The type of the values of the homogeneous dictionary.
     """
-    __slots__ = ('_index_type', '_value_type')
-    _name = 'map'
+    __slots__ = ('_key_type', '_value_type')
+    _name = 'dict'
     _container_rank = 1
     _order = None
 
-    def __init__(self, index_type, value_type):
-        self._index_type = index_type
+    def __init__(self, key_type, value_type):
+        self._key_type = key_type
         self._value_type = value_type
         super().__init__()
 
     def __str__(self):
-        return f'map[{self._index_type.name}, {self._value_type.name}]'
+        return f'dict[{self._key_type}, {self._value_type}]'
 
     def __reduce__(self):
         """
@@ -1009,7 +1009,7 @@ def __reduce__(self):
         args
             A tuple containing any arguments to be passed to the callable.
         """
-        return (self.__class__, (self._index_type, self._value_type))
+        return (self.__class__, (self._key_type, self._value_type))
 
     @property
     def datatype(self):
@@ -1018,7 +1018,56 @@ def datatype(self):
 
         The datatype of the object.
         """
-        return self._index_type.datatype
+        return self._key_type.datatype
+
+    @property
+    def key_type(self):
+        """
+        The type of the keys of the object.
+
+        The type of the keys of the object.
+        """
+        return self._key_type
+
+    @property
+    def value_type(self):
+        """
+        The type of the values of the object.
+
+        The type of the values of the object.
+        """
+        return self._value_type
+
+    @property
+    def container_rank(self):
+        """
+        Number of dimensions of the container.
+
+        Number of dimensions of the object described by the container. This is
+        equal to the number of values required to index an element of this container.
+        """
+        return 1
+
+    @property
+    def rank(self):
+        """
+        Number of dimensions of the object.
+
+        Number of dimensions of the object. If the object is a scalar then
+        this is equal to 0.
+        """
+        return self._container_rank
+
+    @property
+    def order(self):
+        """
+        The data layout ordering in memory.
+
+        Indicates whether the data is stored in row-major ('C') or column-major
+        ('F') format. This is only relevant if rank > 1. When it is not relevant
+        this function returns None.
+        """
+        return None
 
 #==============================================================================
 

pyccel/codegen/printing/pycode.py

@@ -430,6 +430,10 @@ def _print_PythonSet(self, expr):
         args = ', '.join(self._print(i) for i in expr.args)
         return '{'+args+'}'
 
+    def _print_PythonDict(self, expr):
+        args = ', '.join(f'{self._print(k)}: {self._print(v)}' for k,v in expr)
+        return '{'+args+'}'
+
     def _print_PythonBool(self, expr):
         return 'bool({})'.format(self._print(expr.arg))
 

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
+from pyccel.ast.builtins import PythonComplex, PythonDict
 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,
@@ -2249,6 +2249,16 @@ def _visit_PythonSet(self, expr):
                 severity='fatal')
         return expr
 
+    def _visit_PythonDict(self, expr):
+        keys = [self._visit(k) for k in expr.keys]
+        vals = [self._visit(v) for v in expr.values]
+        try:
+            expr = PythonDict(keys, vals)
+        except TypeError as e:
+            errors.report(str(e), symbol=expr,
+                severity='fatal')
+        return expr
+
     def _visit_FunctionCallArgument(self, expr):
         value = self._visit(expr.value)
         a = FunctionCallArgument(value, expr.keyword)

pyccel/parser/syntactic.py

@@ -51,7 +51,7 @@
 from pyccel.ast.operators import IfTernaryOperator
 from pyccel.ast.numpyext  import NumpyMatmul
 
-from pyccel.ast.builtins import PythonTuple, PythonList, PythonSet
+from pyccel.ast.builtins import PythonTuple, PythonList, PythonSet, PythonDict
 from pyccel.ast.builtins import PythonPrint, Lambda
 from pyccel.ast.headers  import MetaVariable, FunctionHeader, MethodHeader
 from pyccel.ast.literals import LiteralInteger, LiteralFloat, LiteralComplex
@@ -399,8 +399,7 @@ def _visit_alias(self, stmt):
             return old
 
     def _visit_Dict(self, stmt):
-        errors.report(PYCCEL_RESTRICTION_TODO,
-                symbol=stmt, severity='error')
+        return PythonDict(self._visit(stmt.keys), self._visit(stmt.values))
 
     def _visit_NoneType(self, stmt):
         return Nil()

tests/epyccel/test_epyccel_dicts.py

@@ -0,0 +1,37 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring
+import pytest
+from pyccel import epyccel
+
+@pytest.fixture( params=[
+        pytest.param("fortran", marks = [
+            pytest.mark.skip(reason="dict methods not implemented in fortran"),
+            pytest.mark.fortran]),
+        pytest.param("c", marks = [
+            pytest.mark.skip(reason="dict methods not implemented in c"),
+            pytest.mark.c]),
+        pytest.param("python", marks = pytest.mark.python)
+    ],
+    scope = "module"
+)
+def language(request):
+    return request.param
+
+def test_dict_init(language):
+    def dict_init():
+        a = {1:1.0, 2:2.0}
+        return a
+    epyc_dict_init = epyccel(dict_init, language = language)
+    pyccel_result = epyc_dict_init()
+    python_result = dict_init()
+    assert isinstance(python_result, type(pyccel_result))
+    assert python_result == pyccel_result
+
+def test_dict_str_keys(language):
+    def dict_str_keys():
+        a = {'a':1, 'b':2}
+        return a
+    epyc_str_keys = epyccel(dict_str_keys, language = language)
+    pyccel_result = epyc_str_keys()
+    python_result = dict_str_keys()
+    assert isinstance(python_result, type(pyccel_result))
+    assert python_result == pyccel_result

tests/errors/syntax_blockers/ex1.py

@@ -1,5 +1,4 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring
-{a: 2, 'b':4}
 ~a
 
 #$ this is invalid comment