fixup! ignore implicit function call in IgnoreUnlessSpelledInSource

Author: Michael137

clang/lib/AST/Expr.cpp

@@ -3183,10 +3183,24 @@ Expr *Expr::IgnoreUnlessSpelledInSource() {
     }
     return E;
   };
+
+  auto IgnoreImplicitCallSingleStep = [](Expr *E) {
+    if (auto *C = dyn_cast<CallExpr>(E)) {
+      auto NumArgs = C->getNumArgs();
+      if (NumArgs == 1 ||
+          (NumArgs > 1 && isa<CXXDefaultArgExpr>(C->getArg(1)))) {
+        Expr *A = C->getArg(0);
+        if (A->getSourceRange() == E->getSourceRange())
+          return A;
+      }
+    }
+    return E;
+  };
+
   return IgnoreExprNodes(
       this, IgnoreImplicitSingleStep, IgnoreImplicitCastsExtraSingleStep,
       IgnoreParensOnlySingleStep, IgnoreImplicitConstructorSingleStep,
-      IgnoreImplicitMemberCallSingleStep);
+      IgnoreImplicitMemberCallSingleStep, IgnoreImplicitCallSingleStep);
 }
 
 bool Expr::isDefaultArgument() const {

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -85,32 +85,6 @@ static bool IsDecomposedVarDecl(VarDecl const *VD) {
   if (!Init)
     return false;
 
-  Init = Init->IgnoreUnlessSpelledInSource();
-  if (!Init)
-    return false;
-
-  // For tuple-like decompositions, if the `get` function
-  // is not a member of the decomposed type, but instead a
-  // free function (e.g., how std::get is specialized for
-  // std::pair), then the initializer is a `CallExpr` and
-  // we need to dig into the argument before unwrapping it
-  // with IgnoreUnlessSpelledInSource.
-  if (auto const *CE = llvm::dyn_cast<CallExpr>(Init)) {
-    if (CE->getNumArgs() == 0)
-      return false;
-
-    // The first argument will be the type we're decomposing.
-    // Technically the getter could have more than 1 argument
-    // (e.g., if they're defaulted arguments), but we don't care
-    // about them because we just need to check whether the
-    // first argument is a DecompositionDecl.
-    auto const *Arg = CE->getArg(0);
-    if (!Arg)
-      return false;
-
-    Init = Arg;
-  }
-
   auto const *RefExpr =
       llvm::dyn_cast_or_null<DeclRefExpr>(Init->IgnoreUnlessSpelledInSource());
   if (!RefExpr)

clang/test/CodeGenCXX/debug-info-structured-binding.cpp

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -emit-llvm -debug-info-kind=standalone -triple %itanium_abi_triple %s -o - | FileCheck %s --implicit-check-not="call void @llvm.dbg.declare"
+// RUN: %clang_cc1 -std=c++23 -emit-llvm -debug-info-kind=standalone -triple %itanium_abi_triple %s -o - | FileCheck %s --implicit-check-not="call void @llvm.dbg.declare"
 
 // CHECK: define {{.*}} i32 @_Z1fv
 // CHECK: #dbg_declare(ptr %{{[a-z]+}}, ![[VAR_0:[0-9]+]], !DIExpression(),
@@ -11,6 +11,10 @@
 // CHECK: #dbg_declare(ptr %k, ![[VAR_7:[0-9]+]], !DIExpression()
 // CHECK: #dbg_declare(ptr %v, ![[VAR_8:[0-9]+]], !DIExpression()
 // CHECK: #dbg_declare(ptr %w, ![[VAR_9:[0-9]+]], !DIExpression()
+// CHECK: #dbg_declare(ptr %m, ![[VAR_10:[0-9]+]], !DIExpression()
+// CHECK: #dbg_declare(ptr %n, ![[VAR_11:[0-9]+]], !DIExpression()
+// CHECK: #dbg_declare(ptr %s, ![[VAR_12:[0-9]+]], !DIExpression()
+// CHECK: #dbg_declare(ptr %p, ![[VAR_13:[0-9]+]], !DIExpression()
 // CHECK: ![[VAR_0]] = !DILocalVariable(name: "a"
 // CHECK: ![[VAR_1]] = !DILocalVariable(name: "x1", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
 // CHECK: ![[VAR_2]] = !DILocalVariable(name: "y1", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
@@ -21,6 +25,10 @@
 // CHECK: ![[VAR_7]] = !DILocalVariable(name: "k", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
 // CHECK: ![[VAR_8]] = !DILocalVariable(name: "v", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
 // CHECK: ![[VAR_9]] = !DILocalVariable(name: "w", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
+// CHECK: ![[VAR_10]] = !DILocalVariable(name: "m", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
+// CHECK: ![[VAR_11]] = !DILocalVariable(name: "n", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
+// CHECK: ![[VAR_12]] = !DILocalVariable(name: "s", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
+// CHECK: ![[VAR_13]] = !DILocalVariable(name: "p", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
 
 struct A {
   int x;
@@ -35,6 +43,22 @@ struct B {
   template<> int get<1>() { return z; }
 };
 
+struct C {
+  int w;
+  int z;
+  template<int> int get(this C&& self);
+  template<> int get<0>(this C&& self) { return self.w; }
+  template<> int get<1>(this C&& self) { return self.z; }
+};
+
+struct D {
+  int w;
+  int z;
+  template<int> int get(int unused = 0);
+  template<> int get<0>(int unused) { return w; }
+  template<> int get<1>(int unused) { return z; }
+};
+
 // Note: the following declarations are necessary for decomposition of tuple-like
 // structured bindings
 namespace std {
@@ -45,6 +69,16 @@ struct tuple_size<B> {
     static constexpr unsigned value = 2;
 };
 
+template<>
+struct tuple_size<C> {
+    static constexpr unsigned value = 2;
+};
+
+template<>
+struct tuple_size<D> {
+    static constexpr unsigned value = 2;
+};
+
 template<unsigned, typename T> struct tuple_element { using type = int; };
 
 // Decomposition of tuple-like bindings but where the `get` methods
@@ -72,5 +106,7 @@ int f() {
   auto &[x2, y2] = a;
   auto [z1, z2] = B{1, 2};
   auto [k, v, w] = std::triple{3, 4, 5};
-  return x1 + y1 + x2 + y2 + z1 + z2 + k + v + w;
+  auto [m, n] = C{2, 3};
+  auto [s, p] = D{2, 3};
+  return x1 + y1 + x2 + y2 + z1 + z2 + k + v + w + m + n + s + p;
 }