[analyzer] C++17: PR41142: Ignore transparent InitListExprs in ExprEngine as well.

[NoQ]

Summary

When evaluating a transparent InitListExpr, eg. {{{{{{X}}}}}}} (when it's equivalent to a plain X), don't try to think of it as of a compound value of type X that contains an X - just think of it as of X itself.

I hope this should take care of the remaining problems that i identified in D59573, for which this patch is a follow-up.

On second thought, there shouldn't be any correctness problems because of multiple inheritance. If there's just one object in the initializer list, it's always at offset 0. So i don't think there are going to be any other changes in the actual behavior - just less crashes.

There's a chance that i missed other cases when a non-aggregate would be accidentally represented as a compound value, but i'm not immediately aware of such cases.

Add the original test from https://bugs.llvm.org/show_bug.cgi?id=41142 (the top-level recursive call would now evaluate into Unknown rather than compoundVal{Unknown} - which is still worse than the correct Undefined value, but it's at least not crashing). Btw, once we make sure it's Undefined, we should probably also add a path note indicating that the function returns a garbage value because there's no return statement in it on the current execution path.

[alexfh]

LG. This fixes (at least, most of) the crashes we observe.

[NoQ]

(the commit message shouldn't have said "CFG", sry)

lib/StaticAnalyzer/Core/ExprEngineC.cpp

void ExprEngine::VisitInitListExpr(const InitListExpr *IE,
                                    ExplodedNodeSet &Dst) {
   StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
 
   ProgramStateRef state = Pred->getState();
   const LocationContext *LCtx = Pred->getLocationContext();
   QualType T = getContext().getCanonicalType(IE->getType());
   unsigned NumInitElements = IE->getNumInits();
 
-  if (!IE->isGLValue() &&
+  if (!IE->isGLValue() && !IE->isTransparent() &&
       (T->isArrayType() || T->isRecordType() || T->isVectorType() ||
        T->isAnyComplexType())) {
     llvm::ImmutableList<SVal> vals = getBasicVals().getEmptySValList();
 
     // Handle base case where the initializer has no elements.
     // e.g: static int* myArray[] = {};
     if (NumInitElements == 0) {
       SVal V = svalBuilder.makeCompoundVal(T, vals);

test/Analysis/initializer.cpp

-// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++11 -verify %s
-// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++17 -DCPLUSPLUS17 -verify %s
-// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s
-// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-inlining=constructors -std=c++17 -DCPLUSPLUS17 -DTEST_INLINABLE_ALLOCATORS -verify %s
+// RUN: %clang_analyze_cc1 -w -verify %s\
+// RUN:   -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks\
+// RUN:   -analyzer-checker=debug.ExprInspection -std=c++11
+// RUN: %clang_analyze_cc1 -w -verify %s\
+// RUN:   -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks\
+// RUN:   -analyzer-checker=debug.ExprInspection -std=c++17
+// RUN: %clang_analyze_cc1 -w -verify %s\
+// RUN:   -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks\
+// RUN:   -analyzer-checker=debug.ExprInspection -std=c++11\
+// RUN:   -DTEST_INLINABLE_ALLOCATORS
+// RUN: %clang_analyze_cc1 -w -verify %s\
+// RUN:   -analyzer-checker=core,unix.Malloc,cplusplus.NewDeleteLeaks\
+// RUN:   -analyzer-checker=debug.ExprInspection -std=c++17\
+// RUN:   -DTEST_INLINABLE_ALLOCATORS
 
 void clang_analyzer_eval(bool);
 
 #include "Inputs/system-header-simulator-cxx.h"
 
 class A {
   int x;
 public:
void foo() {
   B &&br = {}; // no-crash
 
   C c = {}; // no-crash
   const C &cl = {}; // no-crash
   C &&cr = {}; // no-crash
 
   D d = {}; // no-crash
 
-#ifdef CPLUSPLUS17
+#if __cplusplus >= 201703L
   C cd = {{}}; // no-crash
   const C &cdl = {{}}; // no-crash
   C &&cdr = {{}}; // no-crash
 
   const B &bll = {{}}; // no-crash
   const B &bcl = C({{}}); // no-crash
   B &&bcr = C({{}}); // no-crash
 #endif

 }
 
 class C: virtual public A {};
 
 C coo();
 void foo2() {
   C c { coo() }; // no-crash
 }
+
+B foo_recursive() {
+  B b { foo_recursive() };
+}
 } // namespace CXX17_transparent_init_list_exprs