[clang-tidy] Aliasing: Add support for aggregates with references.

[NoQ]

Summary

When a variable is used in an initializer of an aggregate for its reference-type field this counts as aliasing.

This covers a real problem inspired by @aaron.ballman's comment in D96215#2554178. Because in the two checkers that use alias analysis (bugprone-infinite-loop and bugprone-redundant-branch-condition) only variables of plain integral types are being analyzed, we don't seem to need to worry about arrays yet. Arrays of references (unlike structures of references) don't exist. And if an array element is used as a counter (to be decomposed into a reference to an element type), it's a non-starter for those checkers as well.

[aaron.ballman]

LGTM!

clang-tools-extra/clang-tidy/utils/Aliasing.cpp

for (const Decl *D : DS->getDeclGroup()) {
       }
     }
   } else if (const auto *UnOp = dyn_cast<UnaryOperator>(S)) {
     if (UnOp->getOpcode() == UO_AddrOf)
       return isAccessForVar(UnOp->getSubExpr(), Var);
   } else if (const auto *LE = dyn_cast<LambdaExpr>(S)) {
     // Treat lambda capture by reference as a form of taking a reference.
     return capturesByRef(LE->getLambdaClass(), Var);
+  } else if (const auto *ILE = dyn_cast<InitListExpr>(S)) {
+    return llvm::any_of(ILE->inits(), [Var](const Expr *ChildE) {
+      // If the child expression is a reference to Var, this means that it's
+      // used as an initializer of a reference-typed field. Otherwise
+      // it would have been surrounded with an implicit lvalue-to-rvalue cast.
+      return isAccessForVar(ChildE, Var);
+    });
   }
 
   return false;
 }
 
 /// Return whether \p Var has a pointer or reference in \p S.
 static bool hasPtrOrReferenceInStmt(const Stmt *S, const VarDecl *Var) {
   if (isPtrOrReferenceForVar(S, Var))

clang-tools-extra/test/clang-tidy/checkers/bugprone-infinite-loop.cpp

int foo(void) {
   int iterator = 0;
   while (iterator < 10) {
     char *l_tmp_msg = 0;
     pl->debug(pl, "%d: %s\n", iterator, l_tmp_msg);
     iterator++;
   }
   return 0;
 }
+
+struct AggregateWithReference {
+  int &y;
+};
+
+void test_structured_bindings_good() {
+  int x = 0;
+  AggregateWithReference ref { x };
+  auto &[y] = ref;
+  for (; x < 10; ++y) {
+    // No warning. The loop is finite because 'y' is a reference to 'x'.
+  }
+}
+
+struct AggregateWithValue {
+  int y;
+};
+
+void test_structured_bindings_bad() {
+  int x = 0;
+  AggregateWithValue val { x };
+  auto &[y] = val;
+  for (; x < 10; ++y) {
+      // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: this loop is infinite; none of its condition variables (x) are updated in the loop body [bugprone-infinite-loop]
+  }
+}