Clean up unnecessary arguments in the codegen stage (pyccel#1791)

The codegen stage contains lots of old code which sometimes refers to
parameters which no longer exist. Here we clean up some of that code
and remove commented dead code which refers to it. Specifically the
functions `fcode`, `ccode` and `pycode` are removed as well as
`Codegen.doprint` and `Codegen.set_printer`. An instance of `Codegen`
must now be created with the language passed as argument.

Author: EmilyBourne

CHANGELOG.md

@@ -28,6 +28,8 @@ All notable changes to this project will be documented in this file.
 -   \[INTERNALS\] Moved precision from `ast.basic.TypedAstNode` to an internal property of `ast.datatypes.FixedSizeNumericType` objects.
 -   \[INTERNALS\] Use cached `__add__` method to determine result type of arithmetic operations.
 -   \[INTERNALS\] Use cached `__and__` method to determine result type of bitwise comparison operations.
+-   \[INTERNALS\] Removed unused `fcode`, `ccode`, `cwrappercode`, `luacode`, and `pycode` functions from printers.
+-   \[INTERNALS\] Removed unused arguments from methods in `pyccel.codegen.codegen.Codegen`.
 
 ### Deprecated
 

pyccel/codegen/codegen.py

@@ -11,7 +11,6 @@
 from pyccel.codegen.printing.pycode import PythonCodePrinter
 
 from pyccel.ast.core      import FunctionDef, Interface, ModuleHeader
-from pyccel.errors.errors import Errors
 from pyccel.utilities.stage import PyccelStage
 
 _extension_registry = {'fortran': 'f90', 'c':'c',  'python':'py'}
@@ -24,28 +23,31 @@
 
 pyccel_stage = PyccelStage()
 
-class Codegen(object):
-
-    """Abstract class for code generator."""
-
-    def __init__(self, parser, name):
-        """Constructor for Codegen.
-
-        parser: pyccel parser
-
-
-        name: str
-            name of the generated module or program.
-        """
+class Codegen:
+    """
+    Class which handles the generation of code.
+
+    The class which handles the generation of code. This is done by creating an appropriate
+    class inheriting from `CodePrinter` and using it to create strings describing the code
+    that should be printed. This class then takes care of creating the necessary files.
+
+    Parameters
+    ----------
+    parser : SemanticParser
+        The Pyccel semantic parser for a Python program or module. This contains the
+        annotated AST and additional information about the variables scope.
+    name : str
+        Name of the generated module or program.
+    language : str
+        The language which the printer should print to.
+    """
+    def __init__(self, parser, name, language):
         pyccel_stage.set_stage('codegen')
         self._parser   = parser
         self._ast      = parser.ast
         self._name     = name
         self._printer  = None
-        self._language = None
-
-        #TODO verify module name != function name
-        #it generates a compilation error
+        self._language = language
 
         self._stmts = {}
         _structs = [
@@ -63,11 +65,32 @@ def __init__(self, parser, name):
         self._collect_statements()
         self._is_program = self.ast.program is not None
 
+        # instantiate code_printer
+        try:
+            CodePrinterSubclass = printer_registry[language]
+        except KeyError as err:
+            raise ValueError(f'{language} language is not available') from err
+
+        self._printer = CodePrinterSubclass(self.parser.filename)
 
     @property
     def parser(self):
+        """
+        The parser which generated the AST printed by this class.
+
+        The parser which generated the AST printed by this class.
+        """
         return self._parser
 
+    @property
+    def printer(self):
+        """
+        The printer which is used to generate code.
+
+        The printer which is used by this class to generate code in the target language.
+        """
+        return self._printer
+
     @property
     def name(self):
         """Returns the name associated to the source code"""
@@ -134,22 +157,6 @@ def language(self):
 
         return self._language
 
-    def set_printer(self, **settings):
-        """ Set the current codeprinter instance"""
-        # Get language used (default language used is fortran)
-        language = settings.pop('language', 'fortran')
-
-        # Set language
-        if not language in ['fortran', 'c', 'python']:
-            raise ValueError('{} language is not available'.format(language))
-        self._language = language
-
-        # instantiate codePrinter
-        code_printer = printer_registry[language]
-        errors = Errors()
-        # set the code printer
-        self._printer = code_printer(self.parser.filename, **settings)
-
     def get_printer_imports(self):
         """return the imports of the current codeprinter"""
         return self._printer.get_additional_imports()
@@ -176,22 +183,38 @@ def _collect_statements(self):
         self._stmts['interfaces'] = interfaces
         self._stmts['body']       = self.ast
 
-    def doprint(self, **settings):
-        """Prints the code in the target language."""
-        if not self._printer:
-            self.set_printer(**settings)
-        return self._printer.doprint(self.ast)
 
-
-    def export(self, filename=None, **settings):
-        """Export code in filename"""
-        self.set_printer(**settings)
+    def export(self, filename):
+        """
+        Export code to a file with the requested name.
+
+        Generate the code in the target language from the AST and print this code
+        to file. Between 1 and 3 files are generated depending on the AST and the
+        target language. A source file is always generated. In languages with
+        header files, a header file is also generated. Finally if the AST includes
+        a program and the target language is not Python a program source file is
+        also generated. The source and header files are named by appending the
+        extension to the requested filename. The program source file is named by
+        additionally prepending 'prog_' to the requested filename.
+
+        Parameters
+        ----------
+        filename : str
+            The base (i.e. no extensions) of the filename of the file where the
+            code should be printed to.
+
+        Returns
+        -------
+        filename : str
+            The name of the file where the source code was printed.
+        prog_filename : str
+            The name of the file where the source code for the program was printed.
+        """
         ext = _extension_registry[self._language]
         header_ext = _header_extension_registry[self._language]
 
-        if filename is None: filename = self.name
-        header_filename = '{name}.{ext}'.format(name=filename, ext=header_ext)
-        filename = '{name}.{ext}'.format(name=filename, ext=ext)
+        header_filename = f'{filename}.{header_ext}'
+        filename = f'{filename}.{ext}'
 
         # print module header
         if header_ext is not None:

pyccel/codegen/pipeline.py

@@ -260,9 +260,9 @@ def handle_error(stage):
     start_codegen = time.time()
     # Generate .f90 file
     try:
-        codegen = Codegen(semantic_parser, module_name)
+        codegen = Codegen(semantic_parser, module_name, language)
         fname = os.path.join(pyccel_dirpath, module_name)
-        fname, prog_name = codegen.export(fname, language=language)
+        fname, prog_name = codegen.export(fname)
     except NotImplementedError as error:
         msg = str(error)
         errors.report(msg+'\n'+PYCCEL_RESTRICTION_TODO,

pyccel/codegen/printing/ccode.py

@@ -2515,27 +2515,3 @@ def indent_code(self, code):
             level += increase[n]
         return pretty
 
-def ccode(expr, filename, assign_to=None, **settings):
-    """Converts an expr to a string of c code
-
-    expr : Expr
-        A pyccel expression to be converted.
-    filename : str
-        The name of the file being translated. Used in error printing
-    assign_to : optional
-        When given, the argument is used as the name of the variable to which
-        the expression is assigned. Can be a string, ``Symbol``,
-        ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
-        line-wrapping, or for expressions that generate multi-line statements.
-    user_functions : dict, optional
-        A dictionary where keys are ``FunctionClass`` instances and values are
-        their string representations. Alternatively, the dictionary value can
-        be a list of tuples i.e. [(argument_test, cfunction_string)]. See below
-        for examples.
-    dereference : iterable, optional
-        An iterable of symbols that should be dereferenced in the printed code
-        expression. These would be values passed by address to the function.
-        For example, if ``dereference=[a]``, the resulting code would print
-        ``(*a)`` instead of ``a``.
-    """
-    return CCodePrinter(filename, **settings).doprint(expr, assign_to)

pyccel/codegen/printing/cwrappercode.py

@@ -515,31 +515,3 @@ def _print_IndexedElement(self, expr):
             return f'{base}{idxs}'
         else:
             return CCodePrinter._print_IndexedElement(self, expr)
-
-def cwrappercode(expr, filename, target_language, assign_to=None, **settings):
-    """Converts an expr to a string of c wrapper code
-
-    expr : Expr
-        A pyccel expression to be converted.
-    filename : str
-        The name of the file being translated. Used in error printing
-    assign_to : optional
-        When given, the argument is used as the name of the variable to which
-        the expression is assigned. Can be a string, ``Symbol``,
-        ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
-        line-wrapping, or for expressions that generate multi-line statements.
-    precision : integer, optional
-        The precision for numbers such as pi [default=15].
-    user_functions : dict, optional
-        A dictionary where keys are ``FunctionClass`` instances and values are
-        their string representations. Alternatively, the dictionary value can
-        be a list of tuples i.e. [(argument_test, cfunction_string)]. See below
-        for examples.
-    dereference : iterable, optional
-        An iterable of symbols that should be dereferenced in the printed code
-        expression. These would be values passed by address to the function.
-        For example, if ``dereference=[a]``, the resulting code would print
-        ``(*a)`` instead of ``a``.
-    """
-
-    return CWrapperCodePrinter(filename, target_language, **settings).doprint(expr, assign_to)

pyccel/codegen/printing/fcode.py

@@ -3266,25 +3266,3 @@ def _print_BindCClassDef(self, expr):
                  *[a.getter for a in expr.attributes], *[a.setter for a in expr.attributes]]
         sep = f'\n{self._print(SeparatorComment(40))}\n'
         return '', sep.join(self._print(f) for f in funcs)
-
-
-def fcode(expr, filename, assign_to=None, **settings):
-    """Converts an expr to a string of Fortran code
-
-    expr : Expr
-        A pyccel expression to be converted.
-    filename : str
-        The name of the file being translated. Used in error printing
-    assign_to : optional
-        When given, the argument is used as the name of the variable to which
-        the expression is assigned. Can be a string, ``Symbol``,
-        ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
-        line-wrapping, or for expressions that generate multi-line statements.
-    user_functions : dict, optional
-        A dictionary where keys are ``FunctionClass`` instances and values are
-        their string representations. Alternatively, the dictionary value can
-        be a list of tuples i.e. [(argument_test, cfunction_string)]. See below
-        for examples.
-    """
-
-    return FCodePrinter(filename, **settings).doprint(expr, assign_to)

pyccel/codegen/printing/luacode.py

@@ -507,118 +507,3 @@ def indent_code(self, code):
             level += increase[n]
         return pretty
 
-
-def lua_code(expr, assign_to=None, **settings):
-    """Converts an expr to a string of Lua code
-
-    expr : Expr
-        A sympy expression to be converted.
-    assign_to : optional
-        When given, the argument is used as the name of the variable to which
-        the expression is assigned. Can be a string, ``Symbol``,
-        ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
-        line-wrapping, or for expressions that generate multi-line statements.
-    precision : integer, optional
-        The precision for numbers such as pi [default=15].
-    user_functions : dict, optional
-        A dictionary where the keys are string representations of either
-        ``FunctionClass`` or ``UndefinedFunction`` instances and the values
-        are their desired C string representations. Alternatively, the
-        dictionary value can be a list of tuples i.e. [(argument_test,
-        cfunction_string)].  See below for examples.
-    dereference : iterable, optional
-        An iterable of symbols that should be dereferenced in the printed code
-        expression. These would be values passed by address to the function.
-        For example, if ``dereference=[a]``, the resulting code would print
-        ``(*a)`` instead of ``a``.
-    human : bool, optional
-        If True, the result is a single string that may contain some constant
-        declarations for the number symbols. If False, the same information is
-        returned in a tuple of (symbols_to_declare, not_supported_functions,
-        code_text). [default=True].
-    contract: bool, optional
-        If True, ``Indexed`` instances are assumed to obey tensor contraction
-        rules and the corresponding nested loops over indices are generated.
-        Setting contract=False will not generate loops, instead the user is
-        responsible to provide values for the indices in the code.
-        [default=True].
-    locals: dict
-        A dictionary that contains the list of local symbols. these symbols will
-        be preceeded by local for their first assignment.
-
-    Examples
-
-    >>> from sympy import lua_code, symbols, Rational, sin, ceiling, Abs, Function
-    >>> x, tau = symbols("x, tau")
-    >>> lua_code((2*tau)**Rational(7, 2))
-    '8*1.4142135623731*tau.powf(7_f64/2.0)'
-    >>> lua_code(sin(x), assign_to="s")
-    's = x.sin();'
-
-    Simple custom printing can be defined for certain types by passing a
-    dictionary of {"type" : "function"} to the ``user_functions`` kwarg.
-    Alternatively, the dictionary value can be a list of tuples i.e.
-    [(argument_test, cfunction_string)].
-
-    >>> custom_functions = {
-    ...   "ceiling": "CEIL",
-    ...   "Abs": [(lambda x: not x.is_integer, "fabs", 4),
-    ...           (lambda x: x.is_integer, "ABS", 4)],
-    ...   "func": "f"
-    ... }
-    >>> func = Function('func')
-    >>> lua_code(func(Abs(x) + ceiling(x)), user_functions=custom_functions)
-    '(fabs(x) + x.CEIL()).f()'
-
-    ``Piecewise`` expressions are converted into conditionals. If an
-    ``assign_to`` variable is provided an if statement is created, otherwise
-    the ternary operator is used. Note that if the ``Piecewise`` lacks a
-    default term, represented by ``(expr, True)`` then an error will be thrown.
-    This is to prevent generating an expression that may not evaluate to
-    anything.
-
-    >>> from sympy import Piecewise
-    >>> expr = Piecewise((x + 1, x > 0), (x, True))
-    >>> print(lua_code(expr, tau))
-    tau = if (x > 0) {
-        x + 1
-    } else {
-        x
-    };
-
-    Support for loops is provided through ``Indexed`` types. With
-    ``contract=True`` these expressions will be turned into loops, whereas
-    ``contract=False`` will just print the assignment expression that should be
-    looped over:
-
-    >>> from sympy import Eq, IndexedBase, Idx
-    >>> len_y = 5
-    >>> y = IndexedBase('y', shape=(len_y,))
-    >>> t = IndexedBase('t', shape=(len_y,))
-    >>> Dy = IndexedBase('Dy', shape=(len_y-1,))
-    >>> i = Idx('i', len_y-1)
-    >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
-    >>> lua_code(e.rhs, assign_to=e.lhs, contract=False)
-    'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
-
-    Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions
-    must be provided to ``assign_to``. Note that any expression that can be
-    generated normally can also exist inside a Matrix:
-
-    >>> from sympy import Matrix, MatrixSymbol
-    >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
-    >>> A = MatrixSymbol('A', 3, 1)
-    >>> print(lua_code(mat, A))
-    A = [x.powi(2), if (x > 0) {
-        x + 1
-    } else {
-        x
-    }, x.sin()];
-    """
-
-    return LuaCodePrinter(settings).doprint(expr, assign_to)
-
-
-def print_lua_code(expr, **settings):
-    """Prints Lua representation of the given expression."""
-    print((lua_code(expr, **settings)))