Remove deprecated type specifiers in tests (pyccel#2124)

Remove deprecated type specifiers in tests. This is part of phase 2 of
pyccel#1487 . Tests using global templates were changed to use `TypeAlias`
variables. This highlighted some remaining bugs with this method which
have been fixed.

There are still some files remaining which contain headers. These are
either related to macros or related to pyccel#1358 .

## Commit Summary
- Add a static type to `PythonType` to allow the use of `a : type = int`
instead of `a : TypeAlias = int` which is valid in all Python versions
- Add a pickling function for `NumpyNDArrayType`
- Add default arguments in `__new__` methods to avoid the need for
pickling functions
- Ensure a `BitOr` can be used in a `TypeAlias` (`a : TypeAlias = int |
float`)
- Allow a string to be used as a `TypeAlias` (to match syntax used
elsewhere and to allow `TypeAlias` objects to be compatible with all
Python versions)
- Ensure types such as `'T[:]'` or `'tuple[T, bool]'` are properly
handled if `T` is a `TypeAlias`
- Remove tests related only to header syntax
- Use `TypeAlias` instead of global templates
- Remove use of `@types` decorator

## Remaining files containing deprecated type hints
- codegen/fcode/scripts/macros.py
- codegen/fcode/scripts/decorators.py
- codegen/fcode/scripts/functions_inout.py
- codegen/fcode/scripts/headers.py
- codegen/fcode/scripts/returns.py
- codegen/fcode/scripts/multiple_assign.py
- codegen/fcode/scripts/matrix_mul.py
- codegen/fcode/scripts/Functional_Stmts.py
- codegen/fcode/scripts/loops.py
- codegen/ccode/scripts/functions.py
- errors/known_bugs/header_interface.py
- macro/scripts/blas/runtest_dswap.py
- macro/scripts/blas/runtest_dscal.py
- macro/scripts/blas/runtest_dger.py
- macro/scripts/blas/runtest_dgemv.py
- macro/scripts/blas/bugs/dnrm2.py
- macro/scripts/blas/runtest_dcopy.py
- macro/scripts/blas/runtest_daxpy.py
- macro/scripts/blas/runtest_dgemm.py
- macro/scripts/lapack/runtest_dgbtrf.py
- macro/scripts/MPI/mpi4py.py

Author: EmilyBourne

CHANGELOG.md

@@ -62,6 +62,7 @@ All notable changes to this project will be documented in this file.
 -   #1834 : Add support for `@property` decorator.
 -   #2099 : Fix translation of modules containing `__all__`.
 -   #983 : Add support for built-in function `round`.
+-   Add support for `type` as a type annotation.
 -   \[INTERNALS\] Add abstract class `SetMethod` to handle calls to various set methods.
 -   \[INTERNALS\] Added `container_rank` property to `ast.datatypes.PyccelType` objects.
 -   \[INTERNALS\] Add a `__call__` method to `FunctionDef` to create `FunctionCall` instances.
@@ -97,6 +98,7 @@ All notable changes to this project will be documented in this file.
 -   #2085 : Fix calling class methods before they are defined.
 -   #2111 : Fix declaration of class attributes with name conflicts using type annotations.
 -   #2115 : Fix integer handling with NumPy 2.0 on Windows.
+-   Fix handling of union `typing.TypeAlias` objects as type hints.
 
 ### Changed
 

pyccel/ast/builtins.py

@@ -21,7 +21,7 @@
 from .datatypes import HomogeneousTupleType, InhomogeneousTupleType
 from .datatypes import HomogeneousListType, HomogeneousContainerType
 from .datatypes import FixedSizeNumericType, HomogeneousSetType, SymbolicType
-from .datatypes import DictType, VoidType
+from .datatypes import DictType, VoidType, TypeAlias
 from .internals import PyccelFunction, Slice, PyccelArrayShapeElement, Iterable
 from .literals  import LiteralInteger, LiteralFloat, LiteralComplex, Nil
 from .literals  import Literal, LiteralImaginaryUnit, convert_to_literal
@@ -1586,6 +1586,7 @@ class PythonType(PyccelFunction):
     _attribute_nodes = ('_obj',)
     _class_type = SymbolicType()
     _shape = None
+    _static_type = TypeAlias()
 
     def __init__(self, obj):
         if not isinstance (obj, TypedAstNode):

pyccel/ast/numpytypes.py

@@ -432,6 +432,22 @@ def __eq__(self, other):
         return isinstance(other, NumpyNDArrayType) and self.element_type == other.element_type \
                 and self.rank == other.rank and self.order == other.order
 
+    def __reduce__(self):
+        """
+        Function called during pickling.
+
+        For more details see : https://docs.python.org/3/library/pickle.html#object.__reduce__.
+        This function is necessary to ensure that DataTypes remain singletons.
+
+        Returns
+        -------
+        callable
+            A callable to create the object.
+        args
+            A tuple containing any arguments to be passed to the callable.
+        """
+        return (self.__class__, (self._element_type, self._container_rank, self._order))
+
 #==============================================================================
 
 numpy_precision_map = {

pyccel/ast/operators.py

@@ -615,7 +615,7 @@ class PyccelAdd(PyccelArithmeticOperator):
     __slots__ = ()
     _precedence = 12
 
-    def __new__(cls, arg1, arg2, simplify = False):
+    def __new__(cls, arg1 = None, arg2 = None, simplify = False):
         if simplify:
             if isinstance(arg2, PyccelUnarySub):
                 return PyccelMinus(arg1, arg2.args[0], simplify = True)
@@ -699,7 +699,7 @@ class PyccelMul(PyccelArithmeticOperator):
     __slots__ = ()
     _precedence = 13
 
-    def __new__(cls, arg1, arg2, simplify = False):
+    def __new__(cls, arg1 = None, arg2 = None, simplify = False):
         if simplify:
             if (arg1 == 1):
                 return arg2
@@ -749,7 +749,7 @@ class PyccelMinus(PyccelArithmeticOperator):
     __slots__ = ()
     _precedence = 12
 
-    def __new__(cls, arg1, arg2, simplify = False):
+    def __new__(cls, arg1 = None, arg2 = None, simplify = False):
         if simplify:
             if isinstance(arg2, PyccelUnarySub):
                 return PyccelAdd(arg1, arg2.args[0], simplify = True)
@@ -799,7 +799,7 @@ class PyccelDiv(PyccelArithmeticOperator):
     __slots__ = ()
     _precedence = 13
 
-    def __new__(cls, arg1, arg2, simplify=False):
+    def __new__(cls, arg1 = None, arg2 = None, simplify=False):
         if simplify:
             if (arg2 == 1):
                 return arg1
@@ -975,7 +975,7 @@ class PyccelEq(PyccelComparisonOperator):
     __slots__ = ()
     op = "=="
 
-    def __new__(cls, arg1, arg2, simplify = False):
+    def __new__(cls, arg1 = None, arg2 = None, simplify = False):
         if isinstance(arg1, Nil) or isinstance(arg2, Nil):
             return PyccelIs(arg1, arg2)
         else:
@@ -1007,7 +1007,7 @@ class PyccelNe(PyccelComparisonOperator):
     __slots__ = ()
     op = "!="
 
-    def __new__(cls, arg1, arg2, simplify = False):
+    def __new__(cls, arg1 = None, arg2 = None, simplify = False):
         if isinstance(arg1, Nil) or isinstance(arg2, Nil):
             return PyccelIsNot(arg1, arg2)
         else:

pyccel/ast/type_annotations.py

@@ -11,6 +11,8 @@
 
 from .basic import PyccelAstNode
 
+from .bitwise_operators import PyccelBitOr
+
 from .core import FunctionDefArgument
 
 from .datatypes import PythonNativeBool, PythonNativeInt, PythonNativeFloat, PythonNativeComplex
@@ -255,17 +257,24 @@ class SyntacticTypeAnnotation(PyccelAstNode):
 
     Parameters
     ----------
-    dtype : PyccelSymbol | IndexedElement | DottedName
+    dtype : str | IndexedElement | DottedName
         The dtype named in the type annotation.
 
     order : str | None
         The order requested in the type annotation.
     """
     __slots__ = ('_dtype', '_order')
     _attribute_nodes = ('_dtype',)
+
+    def __new__(cls, dtype = None, order = None):
+        if isinstance(dtype, PyccelBitOr):
+            return UnionTypeAnnotation(*[SyntacticTypeAnnotation(d) for d in dtype.args])
+        else:
+            return super().__new__(cls)
+
     def __init__(self, dtype, order = None):
         if not isinstance(dtype, (str, DottedName, IndexedElement)):
-            raise ValueError("Syntactic datatypes should be strings")
+            raise ValueError("Syntactic datatypes should be strings not {type(dtype)}")
         if not (order is None or isinstance(order, str)):
             raise ValueError("Order should be a string")
         self._dtype = dtype

pyccel/parser/semantic.py

@@ -18,6 +18,8 @@
 from sympy import Integer as sp_Integer
 from sympy import ceiling
 
+from textx.exceptions import TextXSyntaxError
+
 #==============================================================================
 from pyccel.utilities.strings import random_string
 from pyccel.ast.basic         import PyccelAstNode, TypedAstNode, ScopedAstNode
@@ -139,6 +141,7 @@
 
 from pyccel.parser.base      import BasicParser
 from pyccel.parser.syntactic import SyntaxParser
+from pyccel.parser.syntax.headers import types_meta
 
 from pyccel.utilities.stage import PyccelStage
 
@@ -922,6 +925,12 @@ def _create_PyccelOperator(self, expr, visited_args):
             The new operator.
         """
         arg1 = visited_args[0]
+        if isinstance(arg1, FunctionDef):
+            msg = ("Function found in a mathematical operation. "
+                   "Are you trying to declare a type? "
+                   "If so then the type object must be used as a type hint.")
+            errors.report(msg,
+                    severity='fatal', symbol=expr)
         class_type = arg1.class_type
         class_base = self.scope.find(str(class_type), 'classes') or get_cls_base(class_type)
         magic_method_name = magic_method_map.get(type(expr), None)
@@ -3289,10 +3298,19 @@ def _visit_Assign(self, expr):
                 lhs = lhs.name
 
             if semantic_lhs_var.class_type is TypeAlias():
-                if not isinstance(rhs, SyntacticTypeAnnotation):
-                    pyccel_stage.set_stage('syntactic')
+                pyccel_stage.set_stage('syntactic')
+                if isinstance(rhs, LiteralString):
+                    try:
+                        annotation = types_meta.model_from_str(rhs.python_value)
+                    except TextXSyntaxError as e:
+                        errors.report(f"Invalid header. {e.message}",
+                                symbol = expr, severity = 'fatal')
+                    rhs = annotation.expr
+                    rhs.set_current_ast(expr.python_ast)
+                elif not isinstance(rhs, (SyntacticTypeAnnotation, FunctionTypeAnnotation,
+                                          VariableTypeAnnotation, UnionTypeAnnotation)):
                     rhs = SyntacticTypeAnnotation(rhs)
-                    pyccel_stage.set_stage('semantic')
+                pyccel_stage.set_stage('semantic')
                 type_annot = self._visit(rhs)
                 self.scope.insert_symbolic_alias(lhs, type_annot)
                 return EmptyNode()
@@ -4154,26 +4172,37 @@ def unpack(ann):
         templates = {t: v for t,v in templates.items() if t in used_type_names}
 
         # Create new temparary templates for the arguments with a Union data type.
-        pyccel_stage.set_stage('syntactic')
         tmp_templates = {}
         new_expr_args = []
         for a in expr.arguments:
-            if isinstance(a.annotation, UnionTypeAnnotation):
-                annotation = [aa for a in a.annotation for aa in unpack(a)]
+            annot = a.annotation
+            if isinstance(annot, UnionTypeAnnotation):
+                annotation = [aa for a in annot for aa in unpack(a)]
+            elif isinstance(annot, SyntacticTypeAnnotation):
+                elem = annot.dtype
+                if isinstance(elem, IndexedElement):
+                    elem = [elem.base] + [a.dtype for a in elem.indices if isinstance(a, SyntacticTypeAnnotation)]
+                else:
+                    elem = [elem]
+                if all(e not in templates for e in elem):
+                    annotation = unpack(self._visit(annot))
+                else:
+                    annotation = [annot]
             else:
-                annotation = [a.annotation]
+                annotation = [annot]
             if len(annotation)>1:
                 tmp_template_name = a.name + '_' + random_string(12)
                 tmp_template_name = self.scope.get_new_name(tmp_template_name)
+                pyccel_stage.set_stage('syntactic')
                 tmp_templates[tmp_template_name] = UnionTypeAnnotation(*[self._visit(vi) for vi in annotation])
                 dtype_symb = PyccelSymbol(tmp_template_name, is_temp=True)
                 dtype_symb = SyntacticTypeAnnotation(dtype_symb)
                 var_clone = AnnotatedPyccelSymbol(a.var.name, annotation=dtype_symb, is_temp=a.var.name.is_temp)
                 new_expr_args.append(FunctionDefArgument(var_clone, bound_argument=a.bound_argument,
                                         value=a.value, kwonly=a.is_kwonly, annotation=dtype_symb))
+                pyccel_stage.set_stage('semantic')
             else:
                 new_expr_args.append(a)
-        pyccel_stage.set_stage('semantic')
 
         templates.update(tmp_templates)
         template_combinations = list(product(*[v.type_list for v in templates.values()]))

tests/epyccel/classes/class_headers.py

@@ -1,7 +1,7 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring
 from typing import TypeAlias
 
-MyType : TypeAlias = float
+MyType : TypeAlias = float | int #pylint: disable=unsupported-binary-operation
 
 def set_i(x : 'MyType[:]', i : 'int', val : MyType):
     x[i] = val

tests/epyccel/modules/Module_9.py

@@ -1,33 +1,30 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring
 from pyccel.decorators import template
 
-#$ header function gen_2(real, int)
-#$ header function gen_2(int, real)
-#$ header function gen_4(T, T)
-#$ header template T(int|real)
-#$ header template R(int|real)
-#$ header template O(real|complex)
-#$ header template S(int|real|complex)
+T : type = 'int | float'
+R : type = 'int | float'
+O : type = 'float | complex'
+S : type = 'int | float | complex'
 
 def gen_1(a : 'float'):
     return a / 10
 
-def gen_2(y, x):
+def gen_2(y : 'float | int', x : 'int | float'):
     return y / x
 
-def gen_3(x : 'T', y : 'T'):
+def gen_3(x : T, y : T):
     return x / y
 
-def gen_4(x, y):
+def gen_4(x : T, y : T):
     return x / y
 
-def gen_5(x : 'T', y : 'R'):
+def gen_5(x : T, y : R):
     return x / y
 
-def gen_6(x : 'S', y : 'S'):
+def gen_6(x : S, y : S):
     return x + y
 
-def gen_7(x : 'T', y : 'T', z : 'R'):
+def gen_7(x : T, y : T, z : R):
     return x + y + z
 
 
@@ -41,7 +38,7 @@ def local_overide_1(x : 'O', y : 'O'):
     return x + y
 
 @template('Z', types=['int', 'real'])
-def tmplt_tmplt_1(x : 'Z', y : 'Z', z : 'R'):
+def tmplt_tmplt_1(x : 'Z', y : 'Z', z : R):
     return x + y + z
 
 def tst_gen_1():

tests/epyccel/modules/generic_functions.py

@@ -11,9 +11,7 @@ def tmplt_1(x : 'Z', y : 'Z'):
 def multi_tmplt_1(x : 'Z', y : 'Z', z : 'Y'):
     return x + y + z
 
-@types('int', 'int')
-@types('int', 'float')
-def multi_heads_1(x, y):
+def multi_heads_1(x : int, y : 'int | float'):
     return x + y
 
 @template(types=['int', 'float'], name = 'Z')
@@ -46,9 +44,7 @@ def default_var_3(x : 'G', y  : 'K' =  False):
         return x
     return x - 1
 
-@types('int', 'int')
-@types('float', 'int')
-def default_var_4(x, y = 5):
+def default_var_4(x : 'int | float', y : int = 5):
     return x + y
 
 
@@ -67,17 +63,13 @@ def optional_var_2(x : 'G', y  : 'K' =  None):
         return x + 1j
     return x + y
 
-@types('int', 'float')
-@types('float', 'float')
-def optional_var_3(x, y = None):
+def optional_var_3(x : 'int | float', y : float = None):
     if y is None:
         return x / 2.0
     return x / y
 
 
-@types('complex', 'int')
-@types('float', 'int')
-def optional_var_4(x, y = None):
+def optional_var_4(x : 'complex | float', y : int = None):
     if y is None:
         return x
     return x + y
@@ -130,9 +122,7 @@ def mix_array_1(x : 'T', a : 'int'):
     x[:] += a
 
 
-@types('complex[:]', 'complex[:]', 'int')
-@types('float[:]', 'int64[:]', 'int')
-def mix_array_2(x, y, a):
+def mix_array_2(x : 'complex[:] | float[:]', y : 'complex[:] | int64[:]', a : int):
     x[:] += a
     y[:] -= a