Unify import strategy (pyccel#1975)

Unify the strategy for handling additional imports in the printing stage
for different languages. This allows `get_additional_imports` and
`add_import` to be moved to the superclass
`codegen.printing.CodePrinter` and will make it easier to handle
different import strategies (e.g. pyccel#1657)

**Commit Summary**
- Move `get_additional_imports` to `codegen.printing.CodePrinter`
- Move `add_import` to `codegen.printing.CodePrinter`
- Use a dictionary for imports in `codegen.printing.FCodePrinter` to
match what is done in `codegen.printing.CCodePrinter`
- Change the storage type of the `_additional_imports` dict in
`codegen.printing.PythonCodePrinter` to match what is done in
`codegen.printing.CCodePrinter`

Author: EmilyBourne

.github/workflows/anaconda_linux.yml

@@ -108,6 +108,7 @@ jobs:
           name: coverage-artifact
           path: .coverage
           retention-days: 1
+          include-hidden-files: true
       - name: "Post completed"
         if: always() && github.event_name != 'push'
         run:

.github/workflows/intel.yml

@@ -102,6 +102,7 @@ jobs:
           name: coverage-artifact
           path: .coverage
           retention-days: 1
+          include-hidden-files: true
       - name: "Post completed"
         if: always() && github.event_name != 'push'
         run:

.github/workflows/linux.yml

@@ -105,6 +105,7 @@ jobs:
           name: coverage-artifact-${{ matrix.python_version }}
           path: .coverage
           retention-days: 3
+          include-hidden-files: true
       - name: "Post completed"
         if: always() && github.event_name != 'push'
         run:

CHANGELOG.md

@@ -87,6 +87,7 @@ All notable changes to this project will be documented in this file.
 -   \[INTERNALS\] Remove unnecessary argument `kind` to `Errors.set_target`.
 -   \[INTERNALS\] Handle STC imports with Pyccel objects.
 -   \[INTERNALS\] Stop using ndarrays as an intermediate step to return arrays from Fortran code.
+-   \[INTERNALS\] Unify the strategy for handling additional imports in the printing stage for different languages.
 
 ### Deprecated
 

pyccel/codegen/printing/ccode.py

@@ -314,28 +314,6 @@ def __init__(self, filename, prefix_module = None):
         self._current_module = None
         self._in_header = False
 
-    def get_additional_imports(self):
-        """return the additional imports collected in printing stage"""
-        return self._additional_imports.keys()
-
-    def add_import(self, import_obj):
-        """
-        Add a new import to the current context.
-
-        Add a new import to the current context. This allows the import to be recognised
-        at the compiling/linking stage. If the source of the import is not new then any
-        new targets are added to the Import object.
-
-        Parameters
-        ----------
-        import_obj : Import
-            The AST node describing the import.
-        """
-        if import_obj.source not in self._additional_imports:
-            self._additional_imports[import_obj.source] = import_obj
-        elif import_obj.target:
-            self._additional_imports[import_obj.source].define_target(import_obj.target)
-
     def _format_code(self, lines):
         return self.indent_code(lines)
 

pyccel/codegen/printing/codeprinter.py

@@ -29,6 +29,7 @@ class CodePrinter:
     language = None
     def __init__(self):
         self._scope = None
+        self._additional_imports = {}
 
     def doprint(self, expr):
         """
@@ -54,6 +55,38 @@ def doprint(self, expr):
         # Format the output
         return ''.join(self._format_code(lines))
 
+    def get_additional_imports(self):
+        """
+        Get any additional imports collected during the printing stage.
+
+        Get any additional imports collected during the printing stage.
+        This is necessary to correctly compile the files.
+
+        Returns
+        -------
+        iterable[str]
+            An iterable of the include strings.
+        """
+        return self._additional_imports.keys()
+
+    def add_import(self, import_obj):
+        """
+        Add a new import to the current context.
+
+        Add a new import to the current context. This allows the import to be recognised
+        at the compiling/linking stage. If the source of the import is not new then any
+        new targets are added to the Import object.
+
+        Parameters
+        ----------
+        import_obj : Import
+            The AST node describing the import.
+        """
+        if import_obj.source not in self._additional_imports:
+            self._additional_imports[import_obj.source] = import_obj
+        elif import_obj.target:
+            self._additional_imports[import_obj.source].define_target(import_obj.target)
+
     @property
     def scope(self):
         """ Return the scope associated with the object being printed

pyccel/codegen/printing/fcode.py

@@ -251,7 +251,6 @@ def __init__(self, filename, prefix_module = None):
         self._current_class    = None
 
         self._additional_code = None
-        self._additional_imports = set()
 
         self.prefix_module = prefix_module
 
@@ -268,10 +267,6 @@ def print_constant_imports(self):
             macros.append(macro)
         return "\n".join(macros)
 
-    def get_additional_imports(self):
-        """return the additional modules collected for importing in printing stage"""
-        return [i.source for i in self._additional_imports]
-
     def set_current_class(self, name):
 
         self._current_class = name
@@ -438,13 +433,14 @@ def _handle_inline_func_call(self, expr, assign_lhs = None):
         func.reinstate_presence_checks()
         func.swap_out_args()
 
-        self._additional_imports.update(func.imports)
+        for i in func.imports:
+            self.add_import(i)
         if func.global_vars or func.global_funcs:
             mod = func.get_direct_user_nodes(lambda x: isinstance(x, Module))[0]
             current_mod = expr.get_user_nodes(Module, excluded_nodes=(FunctionCall,))[0]
             if current_mod is not mod:
-                self._additional_imports.add(Import(mod.name, [AsName(v, v.name) \
-                          for v in (*func.global_vars, *func.global_funcs)]))
+                self.add_import(Import(mod.name, [AsName(v, v.name) \
+                              for v in (*func.global_vars, *func.global_funcs)]))
                 for v in (*func.global_vars, *func.global_funcs):
                     self.scope.insert_symbol(v.name)
 
@@ -560,7 +556,7 @@ def _print_Module(self, expr):
         # ...
 
         contains = 'contains\n' if (expr.funcs or expr.classes or expr.interfaces) else ''
-        imports += ''.join(self._print(i) for i in self._additional_imports)
+        imports += ''.join(self._print(i) for i in self._additional_imports.values())
         imports += "\n" + self.print_constant_imports()
         parts = ['module {}\n'.format(name),
                  imports,
@@ -604,7 +600,7 @@ def _print_Program(self, expr):
 
             decs += '\ninteger :: ierr = -1' +\
                     '\ninteger, allocatable :: status (:)'
-        imports += ''.join(self._print(i) for i in self._additional_imports)
+        imports += ''.join(self._print(i) for i in self._additional_imports.values())
         imports += "\n" + self.print_constant_imports()
         parts = ['program {}\n'.format(name),
                  imports,
@@ -1379,7 +1375,7 @@ def _print_NumpyAmax(self, expr):
             arg_code = self._print(array_arg)
 
         if isinstance(array_arg.dtype.primitive_type, PrimitiveComplexType):
-            self._additional_imports.add(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
+            self.add_import(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
             return f'amax({array_arg})'
         else:
             return f'maxval({arg_code})'
@@ -1392,7 +1388,7 @@ def _print_NumpyAmin(self, expr):
             arg_code = self._print(array_arg)
 
         if isinstance(array_arg.dtype.primitive_type, PrimitiveComplexType):
-            self._additional_imports.add(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
+            self.add_import(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
             return f'amin({array_arg})'
         else:
             return f'minval({arg_code})'
@@ -2774,7 +2770,7 @@ def _print_NumpySign(self, expr):
         arg_code = self._print(arg)
         if isinstance(expr.dtype.primitive_type, PrimitiveComplexType):
             func = PyccelFunctionDef('numpy_sign', NumpySign)
-            self._additional_imports.add(Import('numpy_f90', AsName(func, 'numpy_sign')))
+            self.add_import(Import('numpy_f90', AsName(func, 'numpy_sign')))
             return f'numpy_sign({arg_code})'
         else:
             cast_func = DtypePrecisionToCastFunction[expr.dtype]
@@ -2822,7 +2818,7 @@ def _print_MathFunctionBase(self, expr):
         except KeyError:
             errors.report(PYCCEL_RESTRICTION_TODO, severity='fatal')
         if func_name.startswith("pyc"):
-            self._additional_imports.add(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
+            self.add_import(Import('pyc_math_f90', Module('pyc_math_f90',(),())))
         args = []
         for arg in expr.args:
             if arg.dtype != expr.dtype:

pyccel/codegen/printing/pycode.py

@@ -77,7 +77,6 @@ class PythonCodePrinter(CodePrinter):
     def __init__(self, filename):
         errors.set_target(filename)
         super().__init__()
-        self._additional_imports = {}
         self._aliases = {}
         self._ignore_funcs = []
 
@@ -92,24 +91,6 @@ def _indent_codestring(self, lines):
     def _format_code(self, lines):
         return lines
 
-    def get_additional_imports(self):
-        """return the additional imports collected in printing stage"""
-        imports = [i for tup in self._additional_imports.values() for i in tup[1]]
-        return imports
-
-    def insert_new_import(self, source, target, alias = None):
-        """ Add an import of an object which may have been
-        added by pyccel and therefore may not have been imported
-        """
-        if alias and alias!=target:
-            target = AsName(target, alias)
-        import_obj = Import(source, target)
-        source = str(source)
-        src_info = self._additional_imports.setdefault(source, (set(), []))
-        if any(i not in src_info[0] for i in import_obj.target):
-            src_info[0].update(import_obj.target)
-            src_info[1].append(import_obj)
-
     def _find_functional_expr_and_iterables(self, expr):
         """
         Traverse through the loop representing a FunctionalFor or GeneratorComprehension
@@ -180,9 +161,7 @@ def _get_numpy_name(self, expr):
         type_name = expr.name
         name = self._aliases.get(cls, type_name)
         if name == type_name and cls not in (PythonBool, PythonInt, PythonFloat, PythonComplex):
-            self.insert_new_import(
-                    source = 'numpy',
-                    target = AsName(cls, name))
+            self.add_import(Import('numpy', [AsName(cls, name)]))
         return name
 
     #----------------------------------------------------------------------
@@ -334,7 +313,7 @@ def _print_FunctionDef(self, expr):
                 decorators.pop('template')
             for n,f in decorators.items():
                 if n in pyccel_decorators:
-                    self.insert_new_import(DottedName('pyccel.decorators'), AsName(decorators_mod[n], n))
+                    self.add_import(Import(DottedName('pyccel.decorators'), [AsName(decorators_mod[n], n)]))
                 # TODO - All decorators must be stored in a list
                 if not isinstance(f, list):
                     f = [f]
@@ -394,7 +373,7 @@ def _print_Program(self, expr):
         module = modules[0]
         imports = ''.join(self._print(i) for i in expr.imports if i.source_module is not module)
         body     = self._print(expr.body)
-        imports += ''.join(self._print(i) for i in self.get_additional_imports())
+        imports += ''.join(self._print(i) for i in self._additional_imports.values())
 
         body = imports+body
         body = self._indent_codestring(body)
@@ -635,9 +614,7 @@ def _print_FunctionalFor(self, expr):
 
         name = self._aliases.get(type(expr),'array')
         if name == 'array':
-            self.insert_new_import(
-                    source = 'numpy',
-                    target = AsName(NumpyArray, 'array'))
+            self.add_import(Import('numpy', [AsName(NumpyArray, 'array')]))
 
         return '{} = {}([{} {}])\n'.format(lhs, name, body, for_loops)
 
@@ -814,18 +791,14 @@ def _print_NumpyNorm(self, expr):
     def _print_NumpyNonZero(self, expr):
         name = self._aliases.get(type(expr),'nonzero')
         if name == 'nonzero':
-            self.insert_new_import(
-                    source = 'numpy',
-                    target = AsName(NumpyNonZero, 'nonzero'))
+            self.add_import(Import('numpy', [AsName(NumpyNonZero, 'nonzero')]))
         arg = self._print(expr.array)
         return "{}({})".format(name, arg)
 
     def _print_NumpyCountNonZero(self, expr):
         name = self._aliases.get(type(expr),'count_nonzero')
         if name == 'count_nonzero':
-            self.insert_new_import(
-                    source = 'numpy',
-                    target = AsName(NumpyNonZero, 'count_nonzero'))
+            self.add_import(Import('numpy', [AsName(NumpyNonZero, 'count_nonzero')]))
 
         axis_arg = expr.axis
 
@@ -933,9 +906,7 @@ def _print_Literal(self, expr):
             cast_name = cast_func.name
             name = self._aliases.get(cast_func, cast_name)
             if is_numpy and name == cast_name:
-                self.insert_new_import(
-                        source = 'numpy',
-                        target = AsName(cast_func, cast_name))
+                self.add_import(Import('numpy', [AsName(cast_func, cast_name)]))
             return '{}({})'.format(name, repr(expr.python_value))
         else:
             return repr(expr.python_value)
@@ -983,7 +954,7 @@ def _print_Module(self, expr):
         if free_func:
             self._ignore_funcs.append(free_func)
 
-        imports += ''.join(self._print(i) for i in self.get_additional_imports())
+        imports += ''.join(self._print(i) for i in self._additional_imports.values())
 
         body = ''.join((interfaces, funcs, classes, init_body))