fixup! narrow heuristic for ignoring CallExpr

Author: Michael137

clang/lib/AST/Expr.cpp

@@ -2544,6 +2544,19 @@ Stmt *BlockExpr::getBody() {
 //===----------------------------------------------------------------------===//
 // Generic Expression Routines
 //===----------------------------------------------------------------------===//
+namespace {
+/// Helper to determine wether \c E is a CXXConstructExpr constructing
+/// a DecompositionDecl. Used to skip Clang-generated calls to std::get
+/// for structured bindings.
+bool IsDecompositionDeclRefExpr(const Expr *E) {
+  const Expr *Unrwapped = E->IgnoreUnlessSpelledInSource();
+  const DeclRefExpr *Ref = llvm::dyn_cast_or_null<DeclRefExpr>(Unrwapped);
+  if (!Ref)
+    return false;
+
+  return llvm::isa_and_nonnull<DecompositionDecl *>(Ref->getDecl());
+}
+} // namespace
 
 bool Expr::isReadIfDiscardedInCPlusPlus11() const {
   // In C++11, discarded-value expressions of a certain form are special,
@@ -3163,15 +3176,28 @@ Expr *Expr::IgnoreUnlessSpelledInSource() {
   // Used when Clang generates calls to std::get for decomposing
   // structured bindings.
   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;
-      }
-    }
+    auto *C = dyn_cast<CallExpr>(E);
+    if (!C)
+      return E;
+
+    // Looking for calls to a std::get, which usually just takes
+    // 1 argument (i.e., the structure being decomposed). If it has
+    // more than 1 argument, the others need to be defaulted.
+    unsigned NumArgs = C->getNumArgs();
+    if (NumArgs > 1 && !isa<CXXDefaultArgExpr>(C->getArg(1)))
+      return E;
+
+    Expr *A = C->getArg(0);
+
+    // This was spelled out in source. Don't ignore.
+    if (A->getSourceRange() != E->getSourceRange())
+      return E;
+
+    // If the argument refers to a DecompositionDecl construction,
+    // ignore it.
+    if (IsDecompositionDeclRefExpr(A))
+      return A;
+
     return E;
   };