Add support for type aliases (pyccel#1906)

Add support for non-parametrised type aliases as described at
https://docs.python.org/3/library/typing.html#type-aliases. Fixes pyccel#1544

**Commit Summary**
- Add a `TypeAlias` datatype
- Add support for `typing.TypeAlias`
- Ensure errors are raised when symbolic objects are redefined
- Avoid `class_type.name` (only available for types of user-defined
classes)
- Remove dead code "handling lambdify"
- Stop calling `insert_symbolic_function` (unused, see pyccel#330 )
- Add tests

Author: EmilyBourne

.pylintrc

@@ -102,7 +102,8 @@ disable=invalid-name,
         duplicate-code,
         cyclic-import, # Output not consistent between pylint calls. This should be reactivated if cyclic dependencies can be fixed.
         unused-wildcard-import, # Raised by everything not used in pyccel.errors.messages when using 'from pyccel.errors.messages import *'
-        isinstance-second-argument-not-valid-type # prevents doing isinstance(a, acceptable_iterable_types)
+        isinstance-second-argument-not-valid-type, # prevents doing isinstance(a, acceptable_iterable_types)
+        syntax-error # Ignore syntax errors (usually from testing future Python versions). If the file doesn't run this will be obvious in the tests
 
 
 # Enable the message, report, category or checker with the given id(s). You can

CHANGELOG.md

@@ -30,6 +30,7 @@ All notable changes to this project will be documented in this file.
 -   #1944 : Add the appropriate C language equivalent for declaring a Python `dict` container using the STC library.
 -   #1936 : Add missing C output for inline decorator example in documentation
 -   #1937 : Optimise `pyccel.ast.basic.PyccelAstNode.substitute` method.
+-   #1544 : Add support for `typing.TypeAlias`.
 -   \[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.
 

docs/type_annotations.md

@@ -93,3 +93,25 @@ def f(a : 'T', b : 'T'):
 ```
 
 For more details, see the documentation for [templates](./templates.md).
+
+## Type Aliases
+
+Python also provides type alias objects as described in the Python docs (<https://docs.python.org/3/library/typing.html#type-aliases>). For the moment type parameter lists are not supported. Both the new Python 3.12 syntax and the old syntax are supported. Type aliases cannot be redefined. This allows the user to more easily change between different types. The type name will not appear in the underlying code.
+
+E.g.
+```python
+from typing import TypeAlias
+
+MyType : TypeAlias = float
+
+def set_i(x : 'MyType[:]', i : 'int', val : MyType):
+    x[i] = val
+```
+
+or:
+```python
+type MyType = float
+
+def set_i(x : 'MyType[:]', i : 'int', val : MyType):
+    x[i] = val
+```

pyccel/ast/class_defs.py

@@ -16,7 +16,7 @@
 from .core       import ClassDef, PyccelFunctionDef
 from .datatypes  import (PythonNativeBool, PythonNativeInt, PythonNativeFloat,
                          PythonNativeComplex, StringType, TupleType, CustomDataType,
-                         HomogeneousListType, HomogeneousSetType, DictType)
+                         HomogeneousListType, HomogeneousSetType, DictType, SymbolicType)
 from .numpyext   import (NumpyShape, NumpySum, NumpyAmin, NumpyAmax,
                          NumpyImag, NumpyReal, NumpyTranspose,
                          NumpyConjugate, NumpySize, NumpyResultType, NumpyArray)
@@ -251,7 +251,7 @@ def get_cls_base(class_type):
     NotImplementedError
         Raised if the base class cannot be found.
     """
-    if isinstance(class_type, CustomDataType):
+    if isinstance(class_type, (CustomDataType, SymbolicType)):
         return None
     elif class_type in literal_classes:
         return literal_classes[class_type]

pyccel/ast/datatypes.py

@@ -38,6 +38,7 @@
         'GenericType',
         'SymbolicType',
         'CharType',
+        'TypeAlias',
         # ------------ Container types ------------
         'TupleType',
         'HomogeneousContainerType',
@@ -472,6 +473,21 @@ class CharType(FixedSizeType):
     _name = 'char'
     _primitive_type = PrimitiveCharacterType
 
+#==============================================================================
+class TypeAlias(SymbolicType):
+    """
+    Class representing the type of a symbolic object describing a type descriptor.
+
+    Class representing the type of a symbolic object describing a type descriptor.
+    This type is equivalent to Python's built-in typing.TypeAlias.
+
+    See Also
+    --------
+    typing.TypeAlias : <https://docs.python.org/3/library/typing.html#typing.TypeAlias>.
+    """
+    __slots__ = ()
+    _name = 'TypeAlias'
+
 #==============================================================================
 
 class ContainerType(PyccelType):

pyccel/ast/typingext.py

@@ -9,9 +9,11 @@
 
 from .basic     import TypedAstNode
 from .core      import Module, PyccelFunctionDef
+from .datatypes import TypeAlias
 
 __all__ = (
     'TypingFinal',
+    'TypingTypeAlias',
     'typing_mod'
 )
 
@@ -45,10 +47,24 @@ def arg(self):
         """
         return self._arg
 
+#==============================================================================
+class TypingTypeAlias(TypedAstNode):
+    """
+    Class representing a call to the typing.TypeAlias construct.
+
+    Class representing a call to the typing.TypeAlias construct. This object
+    is only used for type annotations. It is useful for creating a PyccelFunctionDef
+    but instances should not be created.
+    """
+    __slots__ = ()
+    _attribute_nodes = ()
+    _static_type = TypeAlias()
+
 #==============================================================================
 
 typing_funcs = {
         'Final': PyccelFunctionDef('Final', TypingFinal),
+        'TypeAlias': PyccelFunctionDef('TypeAlias', TypingTypeAlias),
     }
 
 typing_mod = Module('typing',

pyccel/parser/semantic.py

@@ -65,7 +65,7 @@
 from pyccel.ast.datatypes import PythonNativeBool, PythonNativeInt, PythonNativeFloat
 from pyccel.ast.datatypes import DataTypeFactory, PrimitiveFloatingPointType
 from pyccel.ast.datatypes import InhomogeneousTupleType, HomogeneousTupleType, HomogeneousSetType, HomogeneousListType
-from pyccel.ast.datatypes import PrimitiveComplexType, FixedSizeNumericType, DictType
+from pyccel.ast.datatypes import PrimitiveComplexType, FixedSizeNumericType, DictType, TypeAlias
 
 from pyccel.ast.functionalexpr import FunctionalSum, FunctionalMax, FunctionalMin, GeneratorComprehension, FunctionalFor
 
@@ -368,7 +368,7 @@ def check_for_variable(self, name):
                 class_def = prefix.cls_base
             except AttributeError:
                 class_def = get_cls_base(prefix.class_type) or \
-                            self.scope.find(prefix.class_type.name, 'classes')
+                            self.scope.find(str(prefix.class_type), 'classes')
 
             attr_name = name.name[-1]
             class_scope = class_def.scope
@@ -689,6 +689,9 @@ def _infer_type(self, expr):
         dict
             Dictionary containing all the type information which was inferred.
         """
+        if not isinstance(expr, TypedAstNode):
+            return {'class_type' : SymbolicType()}
+
         d_var = {
                 'class_type' : expr.class_type,
                 'shape'      : expr.shape,
@@ -1410,6 +1413,10 @@ def _assign_lhs_variable(self, lhs, d_var, rhs, new_expressions, is_augassign,ar
                 else:
                     var = None
             else:
+                symbolic_var = self.scope.find(lhs, 'symbolic_alias')
+                if symbolic_var:
+                    errors.report(f"{lhs} variable represents a symbolic concept. Its value cannot be changed.",
+                            severity='fatal')
                 var = self.scope.find(lhs)
 
             # Variable not yet declared (hence array not yet allocated)
@@ -1936,6 +1943,8 @@ def _get_indexed_type(self, base, args, expr):
             for t in annotation.type_list:
                 t.is_const = True
             return annotation
+        elif isinstance(base, UnionTypeAnnotation):
+            return UnionTypeAnnotation(*[self._get_indexed_type(t, args, expr) for t in base.type_list])
 
         if all(isinstance(a, Slice) for a in args):
             rank = len(args)
@@ -2472,7 +2481,7 @@ def _visit_Slice(self, expr):
     def _visit_IndexedElement(self, expr):
         var = self._visit(expr.base)
 
-        if isinstance(var, (PyccelFunctionDef, VariableTypeAnnotation)):
+        if isinstance(var, (PyccelFunctionDef, VariableTypeAnnotation, UnionTypeAnnotation)):
             return self._get_indexed_type(var, expr.indices, expr)
 
         # TODO check consistency of indices with shape/rank
@@ -2584,7 +2593,7 @@ def _visit_AnnotatedPyccelSymbol(self, expr):
                 possible_args.append(address)
             elif isinstance(t, VariableTypeAnnotation):
                 class_type = t.class_type
-                cls_base = get_cls_base(class_type) or self.scope.find(class_type.name, 'classes')
+                cls_base = self.scope.find(str(class_type), 'classes') or get_cls_base(class_type)
                 v = var_class(class_type, name, cls_base = cls_base,
                         shape = None,
                         is_const = t.is_const, is_optional = False,
@@ -2628,6 +2637,8 @@ def _visit_SyntacticTypeAnnotation(self, expr):
             raise errors.report(PYCCEL_RESTRICTION_TODO + ' Could not deduce type information',
                     severity='fatal', symbol=expr)
 
+    def _visit_VariableTypeAnnotation(self, expr):
+        return expr
 
     def _visit_DottedName(self, expr):
 
@@ -2698,7 +2709,7 @@ def _visit_DottedName(self, expr):
         class_type = d_var['class_type']
         cls_base = get_cls_base(class_type)
         if cls_base is None:
-            cls_base = self.scope.find(class_type.name, 'classes')
+            cls_base = self.scope.find(str(class_type), 'classes')
 
         # look for a class method
         if isinstance(rhs, FunctionCall):
@@ -2980,6 +2991,35 @@ def _visit_Assign(self, expr):
         rhs = expr.rhs
         lhs = expr.lhs
 
+        if isinstance(lhs, AnnotatedPyccelSymbol):
+            semantic_lhs = self._visit(lhs)
+            if len(semantic_lhs) != 1:
+                errors.report("Cannot declare variable with multiple types",
+                        symbol=expr, severity='error')
+            semantic_lhs_var = semantic_lhs[0]
+            if isinstance(semantic_lhs_var, DottedVariable):
+                cls_def = semantic_lhs_var.lhs.cls_base
+                insert_scope = cls_def.scope
+                cls_def.add_new_attribute(semantic_lhs_var)
+            else:
+                insert_scope = self.scope
+
+            lhs = lhs.name
+            if semantic_lhs_var.class_type is TypeAlias():
+                if not isinstance(rhs, SyntacticTypeAnnotation):
+                    pyccel_stage.set_stage('syntactic')
+                    rhs = SyntacticTypeAnnotation(rhs)
+                    pyccel_stage.set_stage('semantic')
+                type_annot = self._visit(rhs)
+                self.scope.insert_symbolic_alias(lhs, type_annot)
+                return EmptyNode()
+
+            try:
+                insert_scope.insert_variable(semantic_lhs_var)
+            except RuntimeError as e:
+                errors.report(e, symbol=expr, severity='error')
+
+
         # Steps before visiting
         if isinstance(rhs, GeneratorComprehension):
             rhs.substitute(rhs.lhs, lhs)
@@ -3024,10 +3064,12 @@ def _visit_Assign(self, expr):
                 d_m_args = {arg.value.name:arg.value for arg in macro.master_arguments
                                   if isinstance(arg.value, Variable)}
 
-                if not sympy_iterable(lhs):
-                    lhs = [lhs]
+                lhs_iter = lhs
+
+                if not sympy_iterable(lhs_iter):
+                    lhs_iter = [lhs]
                 results_shapes = macro.get_results_shapes(args)
-                for m_result, shape, result in zip(macro.results, results_shapes, lhs):
+                for m_result, shape, result in zip(macro.results, results_shapes, lhs_iter):
                     if m_result in d_m_args and not result in args_names:
                         d_result = self._infer_type(d_m_args[m_result])
                         d_result['shape'] = shape
@@ -3071,14 +3113,6 @@ def _visit_Assign(self, expr):
             return rhs
         if isinstance(rhs, ConstructorCall):
             return rhs
-        elif isinstance(rhs, FunctionDef):
-
-            # case of lambdify
-
-            rhs = rhs.rename(expr.lhs.name)
-            for i in rhs.body:
-                i.set_current_ast(python_ast)
-            return rhs
 
         elif isinstance(rhs, CodeBlock) and len(rhs.body)>1 and isinstance(rhs.body[1], FunctionalFor):
             return rhs
@@ -3148,25 +3182,6 @@ def _visit_Assign(self, expr):
                     # case of rhs is a target variable the lhs must be a pointer
                     d['memory_handling'] = 'alias'
 
-        lhs = expr.lhs
-        if isinstance(lhs, AnnotatedPyccelSymbol):
-            semantic_lhs = self._visit(lhs)
-            if len(semantic_lhs) != 1:
-                errors.report("Cannot declare variable with multiple types",
-                        symbol=expr, severity='error')
-            semantic_lhs_var = semantic_lhs[0]
-            if isinstance(semantic_lhs_var, DottedVariable):
-                cls_def = semantic_lhs_var.lhs.cls_base
-                insert_scope = cls_def.scope
-                cls_def.add_new_attribute(semantic_lhs_var)
-            else:
-                insert_scope = self.scope
-            try:
-                insert_scope.insert_variable(semantic_lhs_var)
-            except RuntimeError as e:
-                errors.report(e, symbol=expr, severity='error')
-            lhs = lhs.name
-
         if isinstance(lhs, (PyccelSymbol, DottedName)):
             if isinstance(d_var, list):
                 if len(d_var) == 1:
@@ -3321,12 +3336,9 @@ def _visit_Assign(self, expr):
                     # it is then treated as a def node
 
                     F = self.scope.find(l, 'symbolic_functions')
-                    if F is None:
-                        self.insert_symbolic_function(new_expr)
-                    else:
-                        errors.report(PYCCEL_RESTRICTION_TODO,
-                                      bounding_box=(self.current_ast_node.lineno, self.current_ast_node.col_offset),
-                                      severity='fatal')
+                    errors.report(PYCCEL_RESTRICTION_TODO,
+                                  bounding_box=(self.current_ast_node.lineno, self.current_ast_node.col_offset),
+                                  severity='fatal')
 
             new_expressions.append(new_expr)
 

pyccel/parser/syntactic.py

@@ -42,6 +42,8 @@
 from pyccel.ast.core import CodeBlock
 from pyccel.ast.core import IndexedElement
 
+from pyccel.ast.datatypes import TypeAlias
+
 from pyccel.ast.bitwise_operators import PyccelRShift, PyccelLShift, PyccelBitXor, PyccelBitOr, PyccelBitAnd, PyccelInvert
 from pyccel.ast.operators import PyccelPow, PyccelAdd, PyccelMul, PyccelDiv, PyccelMod, PyccelFloorDiv
 from pyccel.ast.operators import PyccelEq,  PyccelNe,  PyccelLt,  PyccelLe,  PyccelGt,  PyccelGe
@@ -62,7 +64,7 @@
 
 from pyccel.ast.internals import Slice, PyccelSymbol, PyccelFunction
 
-from pyccel.ast.type_annotations import SyntacticTypeAnnotation, UnionTypeAnnotation
+from pyccel.ast.type_annotations import SyntacticTypeAnnotation, UnionTypeAnnotation, VariableTypeAnnotation
 
 from pyccel.parser.base        import BasicParser
 from pyccel.parser.extend_tree import extend_tree
@@ -1353,6 +1355,17 @@ def _visit_Yield(self, stmt):
     def _visit_Starred(self, stmt):
         return StarredArguments(self._visit(stmt.value))
 
+    def _visit_TypeAlias(self, stmt):
+        if stmt.type_params:
+            errors.report("Type parameters are not yet supported on a type alias expression.\n"+PYCCEL_RESTRICTION_TODO,
+                    severity='error', symbol=stmt)
+        self._in_lhs_assign = True
+        name = self._visit(stmt.name)
+        self._in_lhs_assign = False
+        rhs = self._treat_type_annotation(stmt.value, self._visit(stmt.value))
+        type_annotation = UnionTypeAnnotation(VariableTypeAnnotation(TypeAlias(), is_const = True))
+        return Assign(AnnotatedPyccelSymbol(name, annotation=type_annotation), rhs)
+
 #==============================================================================
 
 

tests/epyccel/modules/Module_10.py

@@ -0,0 +1,32 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring
+
+type MyType = float
+
+def set_i(x : 'MyType[:]', i : 'int', val : MyType):
+    x[i] = val
+
+def swap(x : 'MyType[:]', i : 'int', j : 'int'):
+    temp = x[i]
+    x[i] = x[j]
+    x[j] = temp
+
+def inplace_max(x : 'MyType[:]'):
+    n = x.shape[0]
+    # bubble sort
+    for j in range(n):
+        i = n-1-j
+        while i < n-1:
+            if x[i] > x[i+1]:
+                swap(x, i, i+1)
+            else:
+                i+=1
+    return x[-1]
+
+def f(x : 'MyType[:]', y : 'MyType[:]'):
+    n = x.shape[0]
+    for i in range(n):
+        set_i(x, i, float(i))
+    for i in range(n//3):
+        set_i(x[::3], i, -1.0)
+    b = inplace_max(y[:])
+    return b