On 11/3/21 12:04, Patrick Palka wrote:
Here we're incorrectly performing unqualified lookup of 'adl' again at
substitution time for the call adl<I>(t) (for which name lookup at parse
time found nothing) which causes us to reject the testcase because the
second unqualified lookup finds the later-declared variable template
'adl', leading to confusion.  Fixed thusly.

The testcase concepts-recursive-sat1.C needed to be adjusted use ADL
proper instead of relying on this incorrect behavior.

Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for
trunk and perhaps 11 given it's a C++20 bugfix?

OK for trunk.  Not for 11, I think, as it also affects non-C++20 code.

        PR c++/102670

gcc/cp/ChangeLog:

        * pt.c (tsubst_copy_and_build) <case CALL_EXPR>: When looking
        for an identifier callee in the koenig_p case, also look through
        TEMPLATE_ID_EXPR.  Use tsubst_copy to substitute through the
        template arguments of the template-id.

gcc/testsuite/ChangeLog:

        * g++.dg/cpp2a/concepts-recursive-sat1.C:
        * g++.dg/cpp2a/fn-template23.C: New test.
---
  gcc/cp/pt.c                                   | 11 +++++-
  .../g++.dg/cpp2a/concepts-recursive-sat1.C    | 15 +++++---
  gcc/testsuite/g++.dg/cpp2a/fn-template23.C    | 36 +++++++++++++++++++
  3 files changed, 56 insertions(+), 6 deletions(-)
  create mode 100644 gcc/testsuite/g++.dg/cpp2a/fn-template23.C

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 66040035b2f..40f84648ed2 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -20256,7 +20256,10 @@ tsubst_copy_and_build (tree t,
                                            /*done=*/false,
                                            /*address_p=*/false);
          }
-       else if (koenig_p && identifier_p (function))
+       else if (koenig_p
+                && (identifier_p (function)
+                    || (TREE_CODE (function) == TEMPLATE_ID_EXPR
+                        && identifier_p (TREE_OPERAND (function, 0)))))
          {
            /* Do nothing; calling tsubst_copy_and_build on an identifier
               would incorrectly perform unqualified lookup again.
@@ -20269,6 +20272,12 @@ tsubst_copy_and_build (tree t,
               FIXME but doing that causes c++/15272, so we need to stop
               using IDENTIFIER_NODE in that situation.  */
            qualified_p = false;
+
+           if (TREE_CODE (function) == TEMPLATE_ID_EXPR)
+             /* Use tsubst_copy to substitute through the template arguments
+                of the template-id without performing unqualified lookup on
+                the template name.  */
+             function = tsubst_copy (function, args, complain, in_decl);
          }
        else
          {
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-recursive-sat1.C 
b/gcc/testsuite/g++.dg/cpp2a/concepts-recursive-sat1.C
index 22696c30d81..4c178b77946 100644
--- a/gcc/testsuite/g++.dg/cpp2a/concepts-recursive-sat1.C
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-recursive-sat1.C
@@ -3,16 +3,21 @@
  template<int N, typename T>
  concept Foo = requires(T t) { foo<N + 1>(t); }; // { dg-error "template 
instantiation depth" }
-template<int N = 1, typename T = int>
-  requires Foo<N, T>
-int foo(T t)
+namespace ns
  {
-  return foo<N + 1>(t);
+  struct S { };
+
+  template<int N, typename T>
+    requires Foo<N, T>
+  int foo(T t)
+  {
+    return foo<N + 1>(t);
+  }
  }
int main(int, char**)
  {
-  return foo<1>(1);
+  return ns::foo<1>(ns::S{});
  }
// { dg-prune-output "compilation terminated" }
diff --git a/gcc/testsuite/g++.dg/cpp2a/fn-template23.C 
b/gcc/testsuite/g++.dg/cpp2a/fn-template23.C
new file mode 100644
index 00000000000..b85d4c96dab
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/fn-template23.C
@@ -0,0 +1,36 @@
+// PR c++/102670
+// { dg-do compile { target c++20 } }
+
+namespace ns {
+  struct S { };
+
+  template<int I>
+  constexpr int adl(const S &) {
+    return I;
+  }
+}
+
+namespace redirect {
+  template<class T, int I>
+  concept can_call_adl = requires(T t) {
+    adl<I>(t);
+  };
+
+  template<int I>
+  struct adl_fn {
+    template<can_call_adl<I> T>
+    constexpr decltype(auto) operator()(T t) const {
+      return adl<I>(t);
+    }
+  };
+
+  namespace {
+    template<int I>
+    constexpr inline adl_fn<I> adl{};
+  }
+}
+
+int main() {
+  static_assert(redirect::can_call_adl<ns::S, 3>);
+  redirect::adl<3>(ns::S{});
+}


Reply via email to