Support variable declarations in c

pyccel/ast/builtins.py

@@ -1231,6 +1231,7 @@ def print_string(self):
     'min'      : PythonMin,
     'not'      : PyccelNot,
     'map'      : PythonMap,
+    'set'      : PythonSet,
     'str'      : LiteralString,
     'type'     : PythonType,
     'tuple'    : PythonTupleFunction,

pyccel/ast/utilities.py

@@ -17,7 +17,7 @@
                             Concatenate, Module, PyccelFunctionDef)
 
 from .builtins      import (builtin_functions_dict,
-                            PythonRange, PythonList, PythonTuple)
+                            PythonRange, PythonList, PythonTuple, PythonSet)
 from .cmathext      import cmath_mod
 from .datatypes     import HomogeneousTupleType, PythonNativeInt
 from .internals     import PyccelFunction, Slice
@@ -409,7 +409,7 @@ def collect_loops(block, indices, new_index, language_has_vectors = False, resul
     if result is None:
         result = []
     current_level = 0
-    array_creator_types = (Allocate, PythonList, PythonTuple, Concatenate, Duplicate)
+    array_creator_types = (Allocate, PythonList, PythonTuple, Concatenate, Duplicate, PythonSet)
     is_function_call = lambda f: ((isinstance(f, FunctionCall) and not f.funcdef.is_elemental)
                                 or (isinstance(f, PyccelFunction) and not f.is_elemental and not hasattr(f, '__getitem__')
                                     and not isinstance(f, (NumpyTranspose))))

pyccel/codegen/codegen.py

@@ -216,19 +216,19 @@ def export(self, filename):
         header_filename = f'{filename}.{header_ext}'
         filename = f'{filename}.{ext}'
 
+        # print module
+        code = self._printer.doprint(self.ast)
+        with open(filename, 'w') as f:
+            for line in code:
+                f.write(line)
+
         # print module header
         if header_ext is not None:
             code = self._printer.doprint(ModuleHeader(self.ast))
             with open(header_filename, 'w') as f:
                 for line in code:
                     f.write(line)
 
-        # print module
-        code = self._printer.doprint(self.ast)
-        with open(filename, 'w') as f:
-            for line in code:
-                f.write(line)
-
         # print program
         prog_filename = None
         if self.is_program and self.language != 'python':

pyccel/codegen/pipeline.py

@@ -21,6 +21,7 @@
 from pyccel.codegen.utilities      import recompile_object
 from pyccel.codegen.utilities      import copy_internal_library
 from pyccel.codegen.utilities      import internal_libs
+from pyccel.codegen.utilities      import external_libs
 from pyccel.codegen.python_wrapper import create_shared_library
 from pyccel.naming                 import name_clash_checkers
 from pyccel.utilities.stage        import PyccelStage
@@ -334,6 +335,14 @@ def handle_error(stage):
 
             mod_obj.add_dependencies(stdlib)
 
+
+    # Iterate over the external_libs list and determine if the printer
+    # requires an internal lib to be included.
+    for ext_lib_name, ext_src_folder in external_libs.items():
+        if ext_lib_name in codegen.get_printer_imports():
+
+            lib_dest_path = copy_internal_library(ext_src_folder, pyccel_dirpath)
+
     if convert_only:
         # Change working directory back to starting point
         os.chdir(base_dirpath)

pyccel/codegen/printing/ccode.py

@@ -9,9 +9,9 @@
 
 from pyccel.ast.basic     import ScopedAstNode
 
-from pyccel.ast.builtins  import PythonRange, PythonComplex, DtypePrecisionToCastFunction
+from pyccel.ast.builtins  import PythonRange, PythonComplex
 from pyccel.ast.builtins  import PythonPrint, PythonType
-from pyccel.ast.builtins  import PythonList, PythonTuple
+from pyccel.ast.builtins  import PythonList, PythonTuple, PythonSet
 
 from pyccel.ast.core      import Declare, For, CodeBlock
 from pyccel.ast.core      import FuncAddressDeclare, FunctionCall, FunctionCallArgument
@@ -27,7 +27,7 @@
 
 from pyccel.ast.datatypes import PythonNativeInt, PythonNativeBool, VoidType
 from pyccel.ast.datatypes import TupleType, FixedSizeNumericType
-from pyccel.ast.datatypes import CustomDataType, StringType, HomogeneousTupleType
+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
 
@@ -225,6 +225,10 @@
 
 import_dict = {'omp_lib' : 'omp' }
 
+import_stc = {'hset' : 'SET',
+              'vec'  : 'VEC'
+              }
+
 c_imports = {n : Import(n, Module(n, (), ())) for n in
                 ['stdlib',
                  'math',
@@ -810,8 +814,8 @@ def _print_Module(self, expr):
         global_variables = ''.join([self._print(d) for d in expr.declarations])
 
         # Print imports last to be sure that all additional_imports have been collected
-        imports = [Import(self.scope.get_python_name(expr.name), Module(expr.name,(),())), *self._additional_imports.values()]
-        imports = ''.join(self._print(i) for i in imports)
+        imports = Import(expr.name, Module(expr.name,(),()))
+        imports = self._print(imports)
 
         code = ('{imports}\n'
                 '{variables}\n'
@@ -947,6 +951,20 @@ def _print_Import(self, expr):
             source = source.name[-1]
         else:
             source = self._print(source)
+        if expr.target:
+           dtype = expr.target.pop().name
+           if source.startswith('stc/'):
+             dtype_macro = dtype.upper()
+             _,container_type = source.split("/")
+             if container_type in import_stc:
+                class_type_macro = import_stc[container_type]
+             additional_defines = '#define i_use_cmp\n' if class_type_macro == 'VEC' else ''
+             return '\n'.join((f'#ifndef _{class_type_macro}_{dtype_macro}',
+                               f'#define _{class_type_macro}_{dtype_macro}',
+                               f'#define i_key {dtype}',
+                               additional_defines,
+                               f'#include "{source}.h"',
+                               f'#endif\n'))
 
         # Get with a default value is not used here as it is
         # slower and on most occasions the import will not be in the
@@ -1163,6 +1181,13 @@ def find_in_dtype_registry(self, dtype):
                 return 'bool'
 
             key = (primitive_type, dtype.precision)
+        elif isinstance(dtype, (HomogeneousSetType, HomogeneousListType)):
+            container_type = 'hset_' if dtype._name == 'set' else 'vec_'
+            vec_dtype = self.find_in_dtype_registry(dtype.element_type)
+            key = container_type + vec_dtype
+            source = 'stc/'+ container_type[:-1]
+            self.add_import(Import(source, Module(vec_dtype, (), ())))
+            return key
         else:
             key = dtype
 
@@ -1241,6 +1266,9 @@ def get_declare_type(self, expr):
             if expr.is_ndarray or isinstance(expr.class_type, HomogeneousContainerType):
                 if expr.rank > 15:
                     errors.report(UNSUPPORTED_ARRAY_RANK, symbol=expr, severity='fatal')
+                if isinstance(expr.class_type, (HomogeneousSetType, HomogeneousListType)):
+                    dtype = self.find_in_dtype_registry(expr.class_type)
+                    return dtype
                 self.add_import(c_imports['ndarrays'])
                 dtype = 't_ndarray'
             else:
@@ -1525,6 +1553,8 @@ def _print_PyccelArrayShapeElement(self, expr):
     def _print_Allocate(self, expr):
         free_code = ''
         variable = expr.variable
+        if isinstance(variable.class_type, (HomogeneousListType, HomogeneousSetType)):
+            return ''
         if variable.rank > 0:
             #free the array if its already allocated and checking if its not null if the status is unknown
             if  (expr.status == 'unknown'):
@@ -1963,6 +1993,20 @@ def _print_FunctionCall(self, expr):
         else:
             return call_code
 
+    def init_lists_or_sets(self, expr, list_var):
+        """
+        Print the initialization of a python assignment using STC init() method
+        """
+        dtype = self.find_in_dtype_registry(expr.current_user_node.lhs.dtype)
+        container_type = "hset_"if isinstance(expr.class_type, HomogeneousSetType) else "vec_"
+        if (len(expr.args) == 0):
+            return f'{list_var} = c_init({container_type}{dtype},{"{}"});\n'
+
+        keyraw = '{' + ', '.join([self._print(a) for a in expr.args]) + '}'
+        init = f'{list_var} = c_init({container_type}{dtype}, {keyraw});\n'
+
+        return init
+
     def _print_Return(self, expr):
         code = ''
         args = [ObjectAddress(a) if isinstance(a, Variable) and self.is_c_pointer(a) else a for a in expr.expr]
@@ -2105,6 +2149,8 @@ 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)):
+            return prefix_code+self.init_lists_or_sets(rhs, lhs)
         rhs = self._print(expr.rhs)
         return prefix_code+'{} = {};\n'.format(lhs, rhs)
 
@@ -2307,19 +2353,14 @@ def _print_Constant(self, expr):
         if expr == math_constants['inf']:
             self.add_import(c_imports['math'])
             return 'HUGE_VAL'
-        elif expr == math_constants['nan']:
-            self.add_import(c_imports['math'])
-            return 'NAN'
         elif expr == math_constants['pi']:
             self.add_import(c_imports['math'])
             return 'M_PI'
         elif expr == math_constants['e']:
             self.add_import(c_imports['math'])
             return 'M_E'
         else:
-            cast_func = DtypePrecisionToCastFunction[expr.dtype]
-            return self._print(cast_func(expr.value))
-
+            raise NotImplementedError("Constant not implemented")
 
     def _print_Variable(self, expr):
         if self.is_c_pointer(expr):

pyccel/codegen/utilities.py

@@ -12,17 +12,26 @@
 import shutil
 from filelock import FileLock
 import pyccel.stdlib as stdlib_folder
+import pyccel.extensions as ext_folder
 
 from .compiling.basic     import CompileObj
 
 # get path to pyccel/stdlib/lib_name
 stdlib_path = os.path.dirname(stdlib_folder.__file__)
 
+# get path to pyccel/extensions/lib_name
+ext_path = os.path.dirname(ext_folder.__file__)
+
 __all__ = ['copy_internal_library','recompile_object']
 
 #==============================================================================
 language_extension = {'fortran':'f90', 'c':'c', 'python':'py'}
 
+#==============================================================================
+# map external libraries to their folders inside pyccel/extensions
+external_libs = {"stc/vec"      : "stc",
+                 "stc/hset"     : "stc",}
+
 #==============================================================================
 # map internal libraries to their folders inside pyccel/stdlib and their compile objects
 # The compile object folder will be in the pyccel dirpath
@@ -101,8 +110,12 @@ def copy_internal_library(lib_folder, pyccel_dirpath, extra_files = None):
     str
         The location that the files were copied to.
     """
-    # get lib path (stdlib_path/lib_name)
-    lib_path = os.path.join(stdlib_path, lib_folder)
+    # get lib path (stdlib_path/lib_name or ext_path/lib_name)
+    if lib_folder == "stc":
+        lib_path = os.path.join(ext_path, "STC", "include", lib_folder)
+    else:
+        lib_path = os.path.join(stdlib_path, lib_folder)
+
     # remove library folder to avoid missing files and copy
     # new one from pyccel stdlib
     lib_dest_path = os.path.join(pyccel_dirpath, lib_folder)

pyccel/parser/semantic.py

@@ -61,7 +61,7 @@
 from pyccel.ast.class_defs import NumpyArrayClass, TupleClass, get_cls_base
 
 from pyccel.ast.datatypes import CustomDataType, PyccelType, TupleType, VoidType, GenericType
-from pyccel.ast.datatypes import PrimitiveIntegerType, HomogeneousListType, StringType, SymbolicType
+from pyccel.ast.datatypes import PrimitiveIntegerType, HomogeneousListType, StringType, SymbolicType, HomogeneousSetType
 from pyccel.ast.datatypes import PythonNativeBool, PythonNativeInt, PythonNativeFloat
 from pyccel.ast.datatypes import DataTypeFactory, PrimitiveFloatingPointType
 from pyccel.ast.datatypes import InhomogeneousTupleType, HomogeneousTupleType
@@ -1615,7 +1615,7 @@ def _ensure_inferred_type_matches_existing(self, class_type, d_var, var, is_auga
             # to remove memory leaks
             new_expressions.append(Deallocate(var))
 
-        elif class_type != var.class_type:
+        elif class_type != var.class_type and not isinstance(class_type.datatype, GenericType):
             if is_augassign:
                 tmp_result = PyccelAdd(var, rhs)
                 result_type = tmp_result.class_type
@@ -1917,8 +1917,7 @@ def _get_indexed_type(self, base, args, expr):
             else:
                 raise errors.report(f"Unknown annotation base {base}\n"+PYCCEL_RESTRICTION_TODO,
                         severity='fatal', symbol=expr)
-            rank = 1
-            if len(args) == 2 and args[1] is LiteralEllipsis():
+            if len(args) > 0:
                 syntactic_annotation = args[0]
                 if not isinstance(syntactic_annotation, SyntacticTypeAnnotation):
                     pyccel_stage.set_stage('syntactic')
@@ -1930,6 +1929,8 @@ def _get_indexed_type(self, base, args, expr):
                     class_type = HomogeneousTupleType
                 elif dtype_cls is PythonList:
                     class_type = HomogeneousListType
+                elif dtype_cls is PythonSet:
+                    class_type = HomogeneousSetType
                 else:
                     raise errors.report(f"Unknown annotation base {base}\n"+PYCCEL_RESTRICTION_TODO,
                             severity='fatal', symbol=expr)

tests/epyccel/test_epyccel_variable_annotations.py

@@ -166,3 +166,20 @@
 
     assert epyc_homogeneous_tuple_annotation() == homogeneous_tuple_annotation()
     assert isinstance(epyc_homogeneous_tuple_annotation(), type(homogeneous_tuple_annotation()))
+
+@pytest.mark.parametrize( 'language', [
+        pytest.param("c", marks = pytest.mark.c),
+        pytest.param("fortran", marks = [
+            pytest.mark.skip(reason="append() not implemented in fortran"),
+            pytest.mark.fortran]),
+        pytest.param("python", marks = pytest.mark.python)
+    ]
+)
+
+def test_homogeneous_set_annotation_int(language):
+    def homogeneous_set_annotation ():
+        a : set[int]
+        a = {1, 2, 3, 4}
+    epyc_homogeneous_set_annotation =  epyccel(homogeneous_set_annotation, language=language)
+    assert epyc_homogeneous_set_annotation() == homogeneous_set_annotation()
+    assert isinstance(epyc_homogeneous_set_annotation(), type(homogeneous_set_annotation()))