[clang][AST] Propagate the contains-errors bit to DeclRefExpr from VarDecl's initializer.

[hokein]

Summary

Similar to the https://reviews.llvm.org/D86048 (it only sets the bit for C++
code), we propagate the contains-errors bit for C-code path.

Fixes https://github.com/llvm/llvm-project/issues/50236
Fixes https://github.com/llvm/llvm-project/issues/50243
Fixes https://github.com/llvm/llvm-project/issues/48636
Fixes https://github.com/llvm/llvm-project/issues/50320

[aaron.ballman]

LGTM, but please be sure to add a release note (and the newline at the end of the test file). Thank you for the fix!

clang/test/AST/ast-dump-recovery.c

151

Please add a newline to the end of the file. :-)

[shafik]

clang/lib/AST/ComputeDependence.cpp

461

computeDependence does not feel particularly well organized, it is not clear to me how correct it is :-(

532

It feels like we could fold this under the if (const Expr *Init = Var->getAnyInitializer(); Init above and not duplicate code.

[hokein]

address comments and add release note.

clang/lib/AST/ComputeDependence.cpp

if (Expr *SE = IR.Step)
       D |= SE->getDependence();
   }
   return D;
 }
 
 /// Compute the type-, value-, and instantiation-dependence of a
 /// declaration reference
 /// based on the declaration being referenced.
 ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
   auto Deps = ExprDependence::None;
 
   if (auto *NNS = E->getQualifier())
     Deps |= toExprDependence(NNS->getDependence() &
                              ~NestedNameSpecifierDependence::Dependent);
 
   if (auto *FirstArg = E->getTemplateArgs()) {
     unsigned NumArgs = E->getNumTemplateArgs();
ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
 
   //    - an identifier associated by name lookup with one or more declarations
   //      declared with a dependent type
   //
   // [The "or more" case is not modeled as a DeclRefExpr. There are a bunch
   // more bullets here that we handle by treating the declaration as having a
   // dependent type if they involve a placeholder type that can't be deduced.]
   if (Type->isDependentType())
-    return Deps | ExprDependence::TypeValueInstantiation;
+    Deps |= ExprDependence::TypeValueInstantiation;
   else if (Type->isInstantiationDependentType())
     Deps |= ExprDependence::Instantiation;
 
   //    - a conversion-function-id that specifies a dependent type
   if (Decl->getDeclName().getNameKind() ==
       DeclarationName::CXXConversionFunctionName) {
     QualType T = Decl->getDeclName().getCXXNameType();
     if (T->isDependentType())
ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
 
   //    - it is the name of a non-type template parameter,
   if (isa<NonTypeTemplateParmDecl>(Decl))
     return Deps | ExprDependence::ValueInstantiation;
 
   //   - it names a potentially-constant variable that is initialized with an
   //     expression that is value-dependent
   if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
+    if (const Expr *Init = Var->getAnyInitializer();
+        Init && Init->containsErrors())
+      Deps |= ExprDependence::Error;
+
     if (Var->mightBeUsableInConstantExpressions(Ctx)) {
       if (const Expr *Init = Var->getAnyInitializer()) {
         if (Init->isValueDependent())
           Deps |= ExprDependence::ValueInstantiation;
-        if (Init->containsErrors())
-          Deps |= ExprDependence::Error;
       }
     }
 
     // - it names a static data member that is a dependent member of the
     //   current instantiation and is not initialized in a member-declarator,
     if (Var->isStaticDataMember() &&
         Var->getDeclContext()->isDependentContext() &&
         !Var->getFirstDecl()->hasInit()) {

clang/test/AST/ast-dump-recovery.c

 void test6_GH50244() {
   double array[16];
   // CHECK:      UnaryExprOrTypeTraitExpr {{.*}} 'unsigned long' contains-errors sizeof
   // CHECK-NEXT: `-CallExpr {{.*}} '<dependent type>' contains-errors
   // CHECK-NEXT:   |-DeclRefExpr {{.*}} 'int ()'
   // CHECK-NEXT:   `-RecoveryExpr {{.*}} '<dependent type>'
   sizeof array / sizeof foo(undef);
 }
+
+// No crash on DeclRefExpr that refers to ValueDecl with invalid initializers.
+void test7() {
+  int b[] = {""()};
+
+  // CHECK:      CStyleCastExpr {{.*}} 'unsigned int' contains-errors
+  // CHECK-NEXT: | `-DeclRefExpr {{.*}} 'int[]' contains-errors
+  (unsigned) b; // GH50236
+
+  // CHECK:      BinaryOperator {{.*}} '<dependent type>' contains-errors '+'
+  // CHECK-NEXT: |-DeclRefExpr {{.*}} 'int[]' contains-errors
+  // CHECK-NEXT: `-IntegerLiteral {{.*}}
+  b + 1; // GH50243
+
+  // CHECK:      CallExpr {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT: |-DeclRefExpr {{.*}} 'int ()' Function
+  // CHECK-NEXT: `-DeclRefExpr {{.*}} 'int[]' contains-errors
+  return c(b); // GH48636
+}
+int test8_GH50320_b[] = {""()};
+// CHECK: ArraySubscriptExpr {{.*}} 'int' contains-errors lvalue
+int test8 = test_8GH50320_b[0];
 No newline at end of file

clang/test/SemaCXX/cxx11-crashes.cpp

 }
 
 }
 
 namespace b6981007 {
   struct S {}; // expected-note 3{{candidate}}
   void f() {
     S s(1, 2, 3); // expected-error {{no matching}}
-    for (auto x : s) { // expected-error {{invalid range expression of}}
+    for (auto x : s) {
       // We used to attempt to evaluate the initializer of this variable,
       // and crash because it has an undeduced type.
       const int &n(x);
       constexpr int k = sizeof(x);
     }
   }
 }