[ClangTidy] Fix false positives of readability-non-const-parameters check

[JacquesLucke]

Summary

We recently started using Clang Tidy on the Blender source. We found a
couple of false positives of the readability-non-const-parameters check.
One of those is fixed by this patch.

struct MyStruct {
  float *values;
};

void myfunc(float *values) {
  MyStruct mystruct = {values};
}

Without this patch, Clang Tidy reports that the values parameter of
myfunc can be const. It does not recognize that it is assigned to
a non-const data member of MyStruct.

Note, this is the first time I'm working with the LLVM source code.
So please let me know if I'm doing something wrong.

[JacquesLucke]

For some reason arc did not upload all the changes. Maybe because I cloned from github, will check. Anyway, here is the patch.

clang-tools-extra/clang-tidy/readability/NonConstParameterCheck.cpp

if (const auto *B = dyn_cast<BinaryOperator>(S)) {
       }
     } else if (const auto *R = dyn_cast<ReturnStmt>(S)) {
       markCanNotBeConst(R->getRetValue(), true);
     } else if (const auto *U = dyn_cast<UnaryOperator>(S)) {
       markCanNotBeConst(U, true);
     }
   } else if (const auto *VD = Result.Nodes.getNodeAs<VarDecl>("Mark")) {
     const QualType T = VD->getType();
+    if (T->isRecordType()) {
+      if (const auto *ILE = dyn_cast_or_null<InitListExpr>(VD->getInit())) {
+        const auto *D = T->getAs<RecordType>()->getDecl();
+        unsigned InitNr = 0U;
+        for (const auto *F : D->fields()) {
+          if (InitNr >= ILE->getNumInits())
+            break;
+          const auto *Init = ILE->getInit(InitNr++);
+          if (!F->getType().isConstQualified())
+            markCanNotBeConst(Init, true);
+        }
+      }
+    }
     if ((T->isPointerType() && !T->getPointeeType().isConstQualified()) ||
         T->isArrayType())
       markCanNotBeConst(VD->getInit(), true);
   }
 }
 
 void NonConstParameterCheck::addParm(const ParmVarDecl *Parm) {
   // Only add nonconst integer/float pointer parameters.

clang-tools-extra/test/clang-tidy/checkers/readability-non-const-parameter.cpp

 }
 void use_functionpointer2() {
   int (*fp)(int *) = functionpointer2; // <- the parameter 'p' can't be const
 }
 
 // Don't warn about nonconst record pointers that can be const.
 struct XY {
   int *x;
-  int *y;
+  const int *y;
 };
 void recordpointer(struct XY *xy) {
   *(xy->x) = 0;
 }
+// CHECK-MESSAGES: :[[@LINE+1]]:21: warning: pointer parameter 'y' can be
+void initlist1(int *y) {
+  // CHECK-FIXES: {{^}}void initlist1(const int *y) {{{$}}
+  XY xy = {nullptr, y};
+}
+// Don't warn when pointer is assigned to non-const struct member.
+void initlist2(int *x) {
+  XY xy = {x};
+}
 
 class C {
 public:
   C(int *p) : p(p) {}
 
 private:
   int *p;
 };