Lkt lowering: handle the "unique" array method

TN: RA22-015

Author: pmderodat

contrib/lkt/language/parser.py

@@ -199,7 +199,7 @@ def get_builtin_gen_decl(entity_name=T.Symbol):
     )
 
     array_type = Property(
-        Self.array_gen_type.decl.cast(T.TypeDecl), public=True,
+        Self.array_gen_type.decl.cast(T.NamedTypeDecl), public=True,
         doc="Unit method. Return the array builtin type."
     )
 
@@ -210,7 +210,7 @@ def get_builtin_gen_decl(entity_name=T.Symbol):
     )
 
     astlist_type = Property(
-        Self.astlist_gen_type.decl.cast(T.TypeDecl),
+        Self.astlist_gen_type.decl.cast(T.NamedTypeDecl),
         public=True,
         doc="Unit method. Return the ASTList builtin type."
     )

langkit/lkt_lowering.py

@@ -72,6 +72,17 @@ def check_referenced_decl(expr: L.Expr) -> L.Decl:
         assert False, f"Cannot get referenced decl for {expr}: {exc}"
 
 
+def same_node(left: L.LKNode, right: L.LKNode) -> bool:
+    """
+    Return whether ``left`` and ``right`` designate the same node, regardless
+    of generic instantiation information.
+
+    .. todo:: This should probably belong to Liblktlang, in one form or
+       another. See use cases.
+    """
+    return left.unit == right.unit and left.sloc_range == right.sloc_range
+
+
 def pattern_as_str(str_lit: Union[L.StringLit, L.TokenPatternLit]) -> str:
     """
     Return the regexp string associated to this string literal node.
@@ -1144,7 +1155,7 @@ def __init__(self, ctx: CompileCtx, lkt_units: List[L.AnalysisUnit]):
 
         root = lkt_units[0].root
 
-        def get_field(decl: L.TraitDecl, name: str) -> L.Decl:
+        def get_field(decl: L.NamedTypeDecl, name: str) -> L.Decl:
             """
             Return the (assumed existing and unique) declaration called
             ``name`` nested in ``decl``.
@@ -1160,9 +1171,11 @@ def get_field(decl: L.TraitDecl, name: str) -> L.Decl:
         self.array_type = root.p_array_type
         self.astlist_type = root.p_astlist_type
         self.iterator_trait = root.p_iterator_trait
-        self.map_method = get_field(self.iterator_trait, 'map')
         self.analysis_unit_trait = root.p_analysis_unit_trait
 
+        self.map_method = get_field(self.iterator_trait, 'map')
+        self.unique_method = get_field(self.array_type, 'unique')
+
         # Map Lkt nodes for the declarations of builtin types to the
         # corresponding CompiledType instances.
         self.compiled_types = {
@@ -1475,12 +1488,7 @@ def lower_args() -> Tuple[List[AbstractExpression],
                     assert not args
                     return E.New(struct_type, **kwargs)
 
-                # TODO: change liblktlang so that we get an object similar to
-                # InstantiatedGenericType, and have an easy way to check it's
-                # the builtin map function.
-                elif (name_decl.unit, name_decl.sloc_range) == (
-                    self.map_method.unit, self.map_method.sloc_range
-                ):
+                elif same_node(name_decl, self.map_method):
                     # Build variable for iteration variables from the lambda
                     # expression arguments.
                     assert len(call_expr.f_args) == 1
@@ -1507,6 +1515,19 @@ def lower_args() -> Tuple[List[AbstractExpression],
                                                    element_var, index_var)
                     return result
 
+                elif same_node(name_decl, self.unique_method):
+                    # Lower the prefix (the array to copy)
+                    prefix = lower(expr.f_name)
+
+                    # Defensive programming: make sure we have no arguments to
+                    # lower.
+                    args, kwargs = lower_args()
+                    assert not args and not kwargs
+
+                    # ".unique" works with our auto_attr magic: not worth type
+                    # checking until we get rid of the syntax magic.
+                    return prefix.unique  # type: ignore
+
                 else:
                     # Otherwise, this call must be a method invocation. Note
                     # that not all methods map to actual field access in the

testsuite/tests/properties/unique/test.py

@@ -21,5 +21,5 @@ def test(a=T.AnalysisUnit.array):
 
 
 build_and_run(lkt_file='expected_concrete_syntax.lkt', py_script='main.py',
-              lkt_semantic_checks=True)
+              types_from_lkt=True)
 print('Done')