From 69edaa2354d0f89eaec2030b7d91dd7a0dc0bbfe Mon Sep 17 00:00:00 2001
From: Romain Beguet <beguet@adacore.com>
Date: Thu, 16 Nov 2023 00:07:15 +0100
Subject: [PATCH] Try to resolve concatenations using built-in operators first.

---
 ada/ast.py                                    | 20 +++++++++++--------
 .../concat_op_overloading/test.out            |  4 ++--
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/ada/ast.py b/ada/ast.py
index ab3a51ffc..86856eb8f 100644
--- a/ada/ast.py
+++ b/ada/ast.py
@@ -13621,9 +13621,19 @@ def xref_equation():
                     ),
                     concat_operand=Entity.other_operands.at(pos),
                     right=Entity.other_operands.at(pos).operand: Or(
+                        # TODO: this is implementation is actually not correct
+                        # w.r.t. visibility (eng/libadalang/libadalang#1138).
 
-                        # Find the subprogram corresponding to:
-                        # "&" (left, right).
+                        # First, try to resolve this operator using built-in
+                        # operators only.
+                        Entity.operator_no_subprogram_equation(
+                            left, concat_operand, right
+                        ),
+
+                        # If that didn't work, try to resolve it by considering
+                        # visible user-defined overloads of "&". NOTE: for
+                        # performance reasons it is better to first try the
+                        # built-in operators first.
                         concat_subprograms.logic_any(
                             lambda subp: Let(
                                 lambda spec=subp.subp_spec_or_null:
@@ -13637,12 +13647,6 @@ def xref_equation():
                                          spec)
                                 )
                             )
-                        ),
-                        # When no subprogram is found for this concat operator,
-                        # use this equation to infer it's type depending on the
-                        # context.
-                        Entity.operator_no_subprogram_equation(
-                            left, concat_operand, right
                         )
                     )
                 )
diff --git a/testsuite/tests/name_resolution/concat_op_overloading/test.out b/testsuite/tests/name_resolution/concat_op_overloading/test.out
index 96f557ed6..66ba8293a 100644
--- a/testsuite/tests/name_resolution/concat_op_overloading/test.out
+++ b/testsuite/tests/name_resolution/concat_op_overloading/test.out
@@ -43,7 +43,7 @@ Expr: <ConcatOperand test.adb:11:20-11:23>
   type:          <ConcreteTypeDecl ["String"] __standard:105:3-105:57>
   expected type: <ConcreteTypeDecl ["String"] __standard:105:3-105:57>
 Expr: <OpConcat "&" test.adb:11:20-11:21>
-  references:    <DefiningName ""&"" pkg.ads:2:13-2:16>
+  references:    None
   type:          None
   expected type: None
 Expr: <Id "B" test.adb:11:22-11:23>
@@ -97,7 +97,7 @@ Expr: <ConcatOperand test_2.adb:10:20-10:23>
   type:          <ConcreteTypeDecl ["String"] __standard:105:3-105:57>
   expected type: <ConcreteTypeDecl ["String"] __standard:105:3-105:57>
 Expr: <OpConcat "&" test_2.adb:10:20-10:21>
-  references:    <DefiningName ""&"" test_2.adb:4:13-4:16>
+  references:    None
   type:          None
   expected type: None
 Expr: <Id "B" test_2.adb:10:22-10:23>