[clang][Interp] Handle non-primitive locals without initializer

[tbaeder]

Summary

This previously made us crash later on when passing a nullptr initializer to visitLocalInitializer.

[shafik]

LGTM

[tbaeder]

This got merged into https://reviews.llvm.org/D136815, so abandoning.

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitVarDecl(const VarDecl *VD) {
   if (this->isGlobalDecl(VD)) {
     // Has already been registred as a global variable.
     return true;
   }
 
+  const Expr *Init = VD->getInit();
   // Integers, pointers, primitives.
   if (Optional<PrimType> T = this->classify(VD->getType())) {
-    const Expr *Init = VD->getInit();
-
     unsigned Offset =
         this->allocateLocalPrimitive(VD, *T, VD->getType().isConstQualified());
     // Compile the initializer in its own scope.
     if (Init) {
       ExprScope<Emitter> Scope(this);
       if (!this->visit(Init))
         return false;
 
       return this->emitSetLocal(*T, Offset, VD);
     }
     return true;
   }
 
   // Composite types - allocate storage and initialize it.
-  if (Optional<unsigned> Offset = this->allocateLocal(VD))
-    return this->visitLocalInitializer(VD->getInit(), *Offset);
+  if (Optional<unsigned> Offset = this->allocateLocal(VD)) {
+    if (Init)
+      return this->visitLocalInitializer(Init, *Offset);
+    return true;
+  }
 
   return this->bail(VD);
 }
 
 namespace clang {
 namespace interp {
 
 template class ByteCodeStmtGen<ByteCodeEmitter>;
 
 } // namespace interp
 } // namespace clang

clang/test/AST/Interp/cxx20.cpp

 
 constexpr int initializedLocal() {
   int a;
   a = 20;
   return a;
 }
 static_assert(initializedLocal() == 20);
 
+constexpr void uninitializedLocalArray() {
+  int a[]; // expected-error {{needs an explicit size or an initializer}} \
+           // ref-error {{needs an explicit size or an initializer}}
+}
+
 #if 0
 // FIXME: This code should be rejected because we pass an uninitialized value
 //   as a function parameter.
 constexpr int inc(int a) { return a + 1; }
 constexpr int f() {
     int i;
     return inc(i);
 }