Merge branch 'sync/pmderodat/can_reach' into 'master'

Turn "can_reach" into a real property, customizable by language specs

Closes AdaCore#645

See merge request eng/libadalang/langkit!830

Author: pmderodat

langkit/compile_context.py

@@ -1295,6 +1295,39 @@ def properties_logging(self):
         """
         return any(prop.activate_tracing for prop in self.all_properties)
 
+    def check_can_reach_signature(self) -> None:
+        """
+        Check that the root node's "can_reach" signature is conforming.
+        """
+        from langkit.compiled_types import T
+
+        # If the language spec does not create one, the initialisation of the
+        # root node is supposed to create an automatic "can_reach" property.
+        assert self.root_grammar_class is not None
+        fields = self.root_grammar_class.get_abstract_node_data_dict()
+        can_reach = fields["can_reach"]
+
+        qualname = can_reach.qualname
+        args = can_reach.natural_arguments
+
+        with can_reach.diagnostic_context:
+            check_source_language(
+                can_reach.is_property,
+                f"{qualname} must be a property",
+            )
+            check_source_language(
+                can_reach.type.matches(T.Bool),
+                f"{qualname} must return a boolean",
+            )
+            check_source_language(
+                len(args) == 1 and args[0].type.matches(T.root_node),
+                f"{qualname} must take one argument: a bare node",
+            )
+            check_source_language(
+                not can_reach.uses_entity_info,
+                f"{qualname} cannot use entities",
+            )
+
     def compute_properties_callgraphs(self) -> None:
         """
         Compute forwards and backwards properties callgraphs.
@@ -1564,7 +1597,15 @@ def warn(unused_set, message):
             sorted_set = sorted(
                 (p.qualname, p)
                 for p in unused_set
-                if not p.is_internal and not p.artificial
+                if (
+                    # Never warn about implicitly referenced properties:
+                    # internal properties, artificial properties and
+                    # "can_reach" (can come from the language spec but used by
+                    # lexical env lookups).
+                    not p.is_internal
+                    and not p.artificial
+                    and p.indexing_name != "can_reach"
+                )
             )
             for _, p in sorted_set:
                 with p.diagnostic_context:
@@ -2058,6 +2099,8 @@ def lower_grammar_rules(ctx):
                        CompileCtx.compute_uses_entity_info_attr),
             GlobalPass('compute uses envs attribute',
                        CompileCtx.compute_uses_envs_attr),
+            GlobalPass('check can_reach signature',
+                       CompileCtx.check_can_reach_signature),
             EnvSpecPass('check env specs', EnvSpec.check_spec),
             GlobalPass('compute is reachable attribute',
                        CompileCtx.compute_is_reachable_attr),

langkit/compiled_types.py

@@ -2632,6 +2632,10 @@ def __init__(
         :param dsl_name: Name used to represent this type at the DSL level.
             Useful to format diagnostics.
         """
+        from langkit.expressions import Property
+
+        actual_fields = list(fields)
+
         self.raw_name = name
         self.kwless_raw_name = (self.raw_name + names.Name('Node')
                                 if is_keyword(self.raw_name) else
@@ -2708,17 +2712,44 @@ def __init__(
         # Now we have an official root node type, we can create its builtin
         # fields.
         if is_root:
-            fields = self.builtin_properties() + fields
-        self._init_fields(fields)
+            # If the language spec does not define one, create a default
+            # "can_reach" property.
+            if not any(
+                (n if isinstance(n, str) else n.lower) == "can_reach"
+                for n, _ in actual_fields
+            ):
+                from langkit.expressions import No, Self
+                can_reach = Property(
+                    public=False,
+                    type=T.Bool,
+                    expr=(
+                        lambda from_node=T.root_node:
+                        # If there is no from_node node, assume we can access
+                        # everything. Also assume than from_node can reach Self
+                        # if both do not belong to the same unit.
+                        (from_node == No(T.root_node))
+                        | (Self.unit != from_node.unit)  # type: ignore
+                        | (Self < from_node)
+                    ),
+                )
+                # Provide a dummy location for GDB helpers
+                can_reach.location = Location(__file__)
+                can_reach.artificial = True
+                actual_fields.append(("can_reach", can_reach))
+
+            # Always add builtin properties first
+            actual_fields = self.builtin_properties() + actual_fields
+
+        self._init_fields(actual_fields)
 
         # Encode all field names for nodes so that there is no name collision
         # when considering all fields from all nodes.
-        for f in fields:
+        for f in actual_fields:
             if isinstance(f, BaseField):
                 f._internal_name = self.name + f.name
 
         # Make sure that all user fields for nodes are private
-        for _, f_v in fields:
+        for _, f_v in actual_fields:
             with f_v.diagnostic_context:
                 check_source_language(
                     not f_v.is_user_field or
@@ -2756,7 +2787,7 @@ def __init__(
         if env_spec:
             env_spec.ast_node = self
 
-        self.env_spec = env_spec
+        self.env_spec: Opt[EnvSpec] = env_spec
         """
         EnvSpec instance corresponding to this node.
         """

langkit/dsl_unparse.py

@@ -1492,7 +1492,7 @@ def to_emit_dispatcher(prop):
     ${emit_field(field)}$hl
     % endfor
     % for prop in properties:
-    % if not prop.is_internal and not is_builtin_prop(prop) and not prop.is_artificial_dispatcher:
+    % if not prop.is_internal and not is_builtin_prop(prop) and not prop.is_artificial_dispatcher and not prop.artificial:
     ${emit_prop(prop, walker)}$hl
     % endif
     % endfor

langkit/expressions/base.py

@@ -2516,22 +2516,6 @@ def bind(self, dynvar, value, expr):
         return bind_expr
 
 
-@auto_attr
-def can_reach(self, node, from_node):
-    """
-    Return whether `node` can reach `from_node` (two AST nodes), from a
-    sequential viewpoint.  If elements are declared in different units, it will
-    always return True, eg this does not handle general visibility issues, just
-    sequentiality of declarations.
-    """
-    # TODO: this could and should be a built-in property rather than an
-    # expression.
-    node_expr = construct(node, T.root_node)
-    from_node_expr = construct(from_node, T.root_node)
-    return CallExpr('Node_Can_Reach', 'Can_Reach', T.Bool,
-                    [node_expr, from_node_expr], abstract_expr=self)
-
-
 class SelfVariable(AbstractVariable):
 
     _singleton = None

langkit/templates/pkg_implementation_body_ada.mako

@@ -3974,15 +3974,7 @@ package body ${ada_lib_name}.Implementation is
 
    function Can_Reach (El, From : ${T.root_node.name}) return Boolean is
    begin
-      --  Since this function is only used to implement sequential semantics in
-      --  envs, we consider that elements coming from different units are
-      --  always visible for each other, and let the user implement language
-      --  specific visibility rules in the DSL.
-      if El = null or else From = null or else El.Unit /= From.Unit then
-         return True;
-      end if;
-
-      return El.Token_Start_Index < From.Token_Start_Index;
+      return ${T.root_node.kwless_raw_name}_P_Can_Reach (El, From);
    end Can_Reach;
 
    -----------------

langkit/templates/pkg_implementation_spec_ada.mako

@@ -273,7 +273,8 @@ private package ${ada_lib_name}.Implementation is
    --  The combine function on environments metadata does a boolean Or on every
    --  boolean component of the env metadata.
 
-   function Can_Reach (El, From : ${T.root_node.name}) return Boolean;
+   function Can_Reach (El, From : ${T.root_node.name}) return Boolean
+     with Inline;
    --  Return whether El can reach From, from a sequential viewpoint. If
    --  elements are declared in different units, it will always return True,
    --  eg this does not handle general visibility issues, just sequentiality of

testsuite/tests/properties/can_reach/custom/expected_concrete_syntax.lkt

@@ -0,0 +1,29 @@
+import lexer_example
+
+@with_lexer(foo_lexer)
+grammar foo_grammar {
+    @main_rule main_rule <- list*(def)
+    def <- Def("def" name)
+    name <- Name(@identifier)
+}
+
+@abstract class FooNode implements Node[FooNode] {
+
+    fun can_reach(origin: FooNode): Bool =
+    # "foo" defs can never be reached: "foo" Def nodes should never appear
+    # in the result of any lexical env lookups.
+    match node {
+        case d : Def => not (d.name.symbol = "foo")
+        case _ => true
+    }
+
+    @export fun lookup(n: Symbol): Array[FooNode] =
+    node.node_env().get(n, from=node)
+}
+
+class Def : FooNode {
+    @parse_field name: Name
+}
+
+class Name : FooNode implements TokenNode {
+}

testsuite/tests/properties/can_reach/custom/main.py

@@ -0,0 +1,28 @@
+import sys
+
+import libfoolang
+
+
+print("main.py: Running...")
+
+ctx = libfoolang.AnalysisContext()
+unit = ctx.get_from_buffer(
+    "main.txt",
+    b"""
+    def foo
+    def bar
+    def baz
+    """,
+)
+if unit.diagnostics:
+    for d in unit.diagnostics:
+        print(d)
+    sys.exit(1)
+
+for name in ("foo", "bar", "baz", "unknown"):
+    print(f"Looking for {name}:")
+    for n in unit.root.p_lookup(name):
+        print(f"  {n.text}")
+    print("end")
+
+print("main.py: Done.")

testsuite/tests/properties/can_reach/custom/test.out

@@ -0,0 +1,13 @@
+main.py: Running...
+Looking for foo:
+end
+Looking for bar:
+  def bar
+end
+Looking for baz:
+  def baz
+end
+Looking for unknown:
+end
+main.py: Done.
+Done

testsuite/tests/properties/can_reach/custom/test.py

@@ -0,0 +1,39 @@
+"""
+Check that providing a custom "can_reach" has expected effects on env lookups.
+"""
+
+from langkit.dsl import ASTNode, Field, T
+from langkit.envs import EnvSpec, add_to_env_kv
+from langkit.expressions import Self, ignore, langkit_property
+
+from utils import build_and_run
+
+
+class FooNode(ASTNode):
+
+    @langkit_property()
+    def can_reach(origin=T.FooNode):
+        ignore(origin)
+        # "foo" defs can never be reached: "foo" Def nodes should never appear
+        # in the result of any lexical env lookups.
+        return Self.match(
+            lambda d=T.Def: d.name.symbol != "foo",
+            lambda _: True,
+        )
+
+    @langkit_property(public=True)
+    def lookup(n=T.Symbol):
+        return Self.node_env.get(n, from_node=Self)
+
+
+class Def(FooNode):
+    name = Field(type=T.Name)
+    env_spec = EnvSpec(add_to_env_kv(Self.name.symbol, Self))
+
+
+class Name(FooNode):
+    token_node = True
+
+
+build_and_run(lkt_file="expected_concrete_syntax.lkt", py_script="main.py")
+print("Done")