[AST][RecoveryAST] Populate error-bit from Type to Expr.

[hokein]

Summary

Looks like this is a fallout when we introduce the error-bit in Type.

[sammccall]

clang/include/clang/AST/DependenceFlags.h

123

oops! seems like we should be able to observe this directly in an AST dump test too, which should be failing to mark some nodes as error-dependent.
(Not sure if there's a simpler example than your crashing testcase though)

[hokein]

clang/include/clang/AST/DependenceFlags.h

123

yes, in theory. The code path need to go through "error expr" -> "error type" -> "recovery expr", but it seems not easy to produce a case in non-template context, either we bail out too early, or the recovery expression is not built.

clang/include/clang/AST/DependenceFlags.h

enum Bits : uint8_t {
 
     LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/VariablyModified)
   };
 
   Dependence() : V(None) {}
 
   Dependence(TypeDependence D)
       : V(translate(D, TypeDependence::UnexpandedPack, UnexpandedPack) |
-             translate(D, TypeDependence::Instantiation, Instantiation) |
-             translate(D, TypeDependence::Dependent, Dependent) |
-             translate(D, TypeDependence::VariablyModified, VariablyModified)) {
-  }
+          translate(D, TypeDependence::Error, Error) |
+          translate(D, TypeDependence::VariablyModified, VariablyModified)) {}
 
   Dependence(ExprDependence D)
       : V(translate(D, ExprDependence::UnexpandedPack, UnexpandedPack) |
              translate(D, ExprDependence::Instantiation, Instantiation) |
              translate(D, ExprDependence::Type, Type) |
              translate(D, ExprDependence::Value, Value) |
              translate(D, ExprDependence::Error, Error)) {}
 

clang/test/SemaCXX/invalid-template-base-specifier.cpp

 // RUN: %clang_cc1 -frecovery-ast -verify %s
 
-bool Foo(int *); // expected-note {{candidate function not viable}}
+bool Foo(int *); // expected-note {{candidate function not viable}} \
+                 // expected-note {{candidate function not viable}}
 
 template <typename T>
 struct Crash : decltype(Foo(T())) { // expected-error {{no matching function for call to 'Foo'}}
   Crash(){};
 };
 
 void test() { Crash<int>(); } // expected-note {{in instantiation of template class}}
+
+template <typename T>
+using Alias = decltype(Foo(T())); // expected-error {{no matching function for call to 'Foo'}}
+template <typename T>
+struct Crash2 : decltype(Alias<T>()) { // expected-note {{in instantiation of template type alias 'Alias' requested here}}
+  Crash2(){};
+};
+
+void test2() { Crash2<int>(); } // expected-note {{in instantiation of template class 'Crash2<int>' requested here}}