revert deducing this in member-function lambdas (gcc 14/15 bug PR118291)

Author: Cameron Custer

library/trees/hld.hpp

@@ -14,24 +14,24 @@ template<bool VALS_EDGES> struct HLD {
   int n;
   vi p, siz, rt, tin;
   HLD(auto& g): n(sz(g)), p(n), siz(n, 1), rt(n), tin(n) {
-    auto dfs1 = [&](this auto&& dfs1, int u) -> void {
+    auto dfs1 = [&](auto dfs1, int u) -> void {
       for (int& v : g[u]) {
         erase(g[v], p[v] = u);
-        dfs1(v);
+        dfs1(dfs1, v);
         siz[u] += siz[v];
         if (siz[v] > siz[g[u][0]]) swap(v, g[u][0]);
       }
     };
-    dfs1(0);
+    dfs1(dfs1, 0);
     int tim = 0;
-    auto dfs2 = [&](this auto&& dfs2, int u) -> void {
+    auto dfs2 = [&](auto dfs2, int u) -> void {
       tin[u] = tim++;
       for (int v : g[u]) {
         rt[v] = (v == g[u][0] ? rt[u] : v);
-        dfs2(v);
+        dfs2(dfs2, v);
       }
     };
-    dfs2(0);
+    dfs2(dfs2, 0);
   }
   void path(int u, int v, auto f) {
     for (;; v = p[rt[v]]) {

library/trees/lca_rmq.hpp

@@ -16,13 +16,14 @@ struct LCA {
   LCA(const auto& g):
     n(sz(g)), tin(n), siz(n, 1), d(n), p(n) {
     vi order;
-    auto dfs = [&](this auto&& dfs, int u) -> void {
+    auto dfs = [&](auto&& dfs, int u) -> void {
       tin[u] = sz(order), order.push_back(u);
       for (int v : g[u])
         if (v != p[u])
-          d[v] = d[p[v] = u] + 1, dfs(v), siz[u] += siz[v];
+          d[v] = d[p[v] = u] + 1, dfs(dfs, v),
+          siz[u] += siz[v];
     };
-    dfs(0);
+    dfs(dfs, 0);
     rmq = {order,
       [&](int u, int v) { return d[u] < d[v] ? u : v; }};
   }

library/trees/linear_lca.hpp

@@ -13,17 +13,17 @@ struct linear_lca {
   linear_lca(const auto& g):
     n(sz(g)), d(n), in(n), asc(n), head(n + 1) {
     vector<pii> order;
-    auto dfs = [&](this auto&& dfs, int u, int p) -> void {
+    auto dfs = [&](auto&& dfs, int u, int p) -> void {
       order.emplace_back(u, p), in[u] = sz(order);
       for (int v : g[u])
         if (v != p) {
           d[v] = 1 + d[u];
-          dfs(v, u);
+          dfs(dfs, v, u);
           head[in[v]] = u;
           if (lsb(in[u]) < lsb(in[v])) in[u] = in[v];
         }
     };
-    dfs(0, 0);
+    dfs(dfs, 0, 0);
     for (auto [u, p] : order) asc[u] = asc[p] | lsb(in[u]);
   }
   int lca(int u, int v) {

library/trees/tree_lift.hpp

@@ -11,14 +11,14 @@
 struct tree_lift {
   vi d, p, j;
   tree_lift(const auto& g): d(sz(g)), p(d), j(d) {
-    auto dfs = [&](this auto&& dfs, int u) -> void {
+    auto dfs = [&](auto&& dfs, int u) -> void {
       int up = d[u] + d[j[j[u]]] == 2 * d[j[u]] ? j[j[u]]
                                                 : u;
       for (int v : g[u])
         if (v != p[u])
-          d[v] = d[p[v] = u] + 1, j[v] = up, dfs(v);
+          d[v] = d[p[v] = u] + 1, j[v] = up, dfs(dfs, v);
     };
-    dfs(0);
+    dfs(dfs, 0);
   }
   int kth_par(int u, int k) {
     int anc_d = d[u] - k;

library/trees/uncommon/hagerup_kth_par.hpp

@@ -21,22 +21,22 @@ template<int K = 2> struct hagerup {
       jmp[t] = st[max(0, s - K * (t & -t))];
       t++;
     };
-    auto dfs = [&](this auto&& dfs, int u, int p) -> void {
+    auto dfs = [&](auto&& dfs, int u, int p) -> void {
       int& l = leaf[u] = st[d[u]] = u;
       pos[u] = t;
       calc(d[u]);
       for (int v : g[u])
         if (v != p) {
           d[v] = 1 + d[u];
-          dfs(v, u);
+          dfs(dfs, v, u);
           if (d[l] < d[leaf[v]]) l = leaf[v];
           calc(d[u]);
         }
       int s = (d[l] - d[u]) * (2 * K + 3) / K;
       s = min(max(s, 2 * K), d[l] + 1);
       rep(i, sz(lad[l]), s) lad[l].push_back(st[d[l] - i]);
     };
-    dfs(0, 0);
+    dfs(dfs, 0, 0);
   }
   int kth_par(int u, int k) {
     assert(0 <= k && k <= d[u]);

library/trees/uncommon/ladder_decomposition.hpp

@@ -20,13 +20,13 @@ struct ladder {
     n(sz(g)), d(n), p(n), idx(n), lad(2 * n) {
     int i = 0;
     vi st(n);
-    auto dfs = [&](this auto&& dfs, int u) -> vi {
+    auto dfs = [&](auto&& dfs, int u) -> vi {
       vi path;
       st[d[u]] = u;
       for (int v : g[u])
         if (v != p[u]) {
           d[v] = d[p[v] = u] + 1;
-          vi x = dfs(v);
+          vi x = dfs(dfs, v);
           if (sz(x) > sz(path)) swap(x, path);
           for (int y : x) idx[y] = i;
           for (int y : x) lad[i++] = y;
@@ -36,7 +36,7 @@ struct ladder {
       path.push_back(u);
       return path;
     };
-    vi x = dfs(0);
+    vi x = dfs(dfs, 0);
     for (int y : x) idx[y] = i;
     for (int y : x) lad[i++] = y;
     jmp = treeJump(p);

library/trees/uncommon/linear_kth_par.hpp

@@ -23,14 +23,14 @@ struct linear_kth_par {
         jmp[t] += st[du - k];
       d_tour[t++] = du;
     };
-    auto dfs = [&](this auto&& dfs, int u, int p) -> vi {
+    auto dfs = [&](auto&& dfs, int u, int p) -> vi {
       vi path;
       tin[st[d[u]] = u] = t;
       calc(d[u]);
       for (int v : g[u])
         if (v != p) {
           d[v] = d[u] + 1;
-          vi x = dfs(v, u);
+          vi x = dfs(dfs, v, u);
           calc(d[u]);
           if (sz(x) > sz(path)) swap(x, path);
           for (int y : x) idx[y] = i;
@@ -41,7 +41,7 @@ struct linear_kth_par {
       path.push_back(u);
       return path;
     };
-    vi x = dfs(0, 0);
+    vi x = dfs(dfs, 0, 0);
     for (int y : x) idx[y] = i;
     for (int y : x) lad[i++] = y;
   }