[clang] Fix a constant evaluator crash on a NULL-type expr.

[sammccall]

This is a reasonable immediate fix, but creating null-typed expressions that live *outside* the recoveryexpr seems scary, and likely to violate expected invariants elsewhere too...

[hokein]

In D124384#3471917, @sammccall wrote:

This is a reasonable immediate fix, but creating null-typed expressions that live *outside* the recoveryexpr seems scary, and likely to violate expected invariants elsewhere too...

Yeah, the fundamental issue is that we create a null-typed expression (ParenListExpr) outside a template context, which is similar to our prior case where we have a dependent expression outside a template context. Perhaps it violates invariants in other places as well, but this is the first time.

clang/lib/AST/ExprConstant.cpp

static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
   // variables (in the latter case, use-before-assign isn't UB; in the former,
   // we have no clue what they'll be assigned to).
   const auto *VD =
       dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
   if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
     return false;
 
   const Expr *Init = VD->getAnyInitializer();
-  if (!Init)
+  if (!Init || Init->getType().isNull())
     return false;
 
   const Expr *E = Init->IgnoreParens();
   if (!tryUnwrapAllocSizeCall(E))
     return false;
 
   // Store E instead of E unwrapped so that the type of the LValue's base is
   // what the user wanted.

clang/test/SemaCXX/recovery-expr-type.cpp

 
 namespace test13 {
 enum Circular {             // expected-note {{not complete until the closing '}'}}
   Circular_A = Circular(1), // expected-error {{'test13::Circular' is an incomplete type}}
 };
 // Enumerators can be evaluated (they evaluate as zero, but we don't care).
 static_assert(Circular_A == 0 && Circular_A != 0, ""); // expected-error {{static_assert failed}}
 }
+
+namespace test14 {
+extern "C" void *memset(void *, int b, unsigned long) {
+  int * const c(undef()); // expected-error {{undeclared identifier}}
+  // Verify we do not crash on evaluating *c whose initializer is a NULL-type ParenListExpr!
+  memset(c, 0, *c); // crash1
+
+  b = __builtin_object_size(c, 0); // crash2
+}
+}