[AST][RecoveryExpr] Add error-bit to NestNameSpecifierDependence and TemplateNameDependence.

[hokein]

Summary

We might lose the error-bit if the error-bit goes through the code path
"error type/expr" -> "error template argument" -> "nested name specifier" ->
... -> "template Specialization type"

Template name also needs this, as a template can be nested into
an error specifier, e.g. templateName apply in
TC<decltype(<recovery-expr>(Foo, int()))>::template apply

[hokein]

friendly ping, we start encountering this crash in production.

another reduced testcase:

using a = decltype(b())::a;
  template < class c > class d {
    using UnderlyingBuilder = c::UnderlyingBuilder:template < class > class e  
    class f  {
    using g = UnderlyingBuildertype;
    }class StorageNoDestruct
        : c::k<
              e< f:g > > {}  
  using h = StorageNoDestructtype;
    static_assert(alignof(h) == alignof(f),
                  ""}template < class > class i {
  using UnderlyingBuilder =
        a;
    template < class > class k  
  }class j 
      : d< i< j  > >

[sammccall]

clang/include/clang/AST/DependenceFlags.h

67

FWIW I don't think this macro is worth the complexity, maybe we should expand it out at some point.

clang/include/clang/AST/DependenceFlags.h

 //===--- DependenceFlags.h ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_AST_DEPENDENCEFLAGS_H
 #define LLVM_CLANG_AST_DEPENDENCEFLAGS_H
enum TypeDependence : uint8_t {
 
     DependentInstantiation = Dependent | Instantiation,
 
     LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Error)
   };
 };
 using TypeDependence = TypeDependenceScope::TypeDependence;
 
-struct TemplateArgumentDependenceScope {
-  enum TemplateArgumentDependence : uint8_t {
-    UnexpandedPack = 1,
-    Instantiation = 2,
-    Dependent = 4,
-
-    Error = 8,
-
-    DependentInstantiation = Dependent | Instantiation,
-    None = 0,
-    All = 15,
-    LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Error)
-  };
-};
-using TemplateArgumentDependence =
-    TemplateArgumentDependenceScope ::TemplateArgumentDependence;
-
 #define LLVM_COMMON_DEPENDENCE(NAME)                                           \
   struct NAME##Scope {                                                         \
     enum NAME : uint8_t {                                                      \
       UnexpandedPack = 1,                                                      \
       Instantiation = 2,                                                       \
       Dependent = 4,                                                           \
+      Error = 8,                                                               \
                                                                                \
       None = 0,                                                                \
       DependentInstantiation = Dependent | Instantiation,                      \
-      All = 7,                                                                 \
+      All = 15,                                                                \
                                                                                \
-      LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Dependent)                    \
+      LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Error)                        \
     };                                                                         \
   };                                                                           \
   using NAME = NAME##Scope::NAME;
 
 LLVM_COMMON_DEPENDENCE(NestedNameSpecifierDependence)
 LLVM_COMMON_DEPENDENCE(TemplateNameDependence)
+LLVM_COMMON_DEPENDENCE(TemplateArgumentDependence)
 #undef LLVM_COMMON_DEPENDENCE
 
 // A combined space of all dependence concepts for all node types.
 // Used when aggregating dependence of nodes of different types.
 class Dependence {
 public:
   enum Bits : uint8_t {
     None = 0,
public:
 
   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)) {}
 
   Dependence(NestedNameSpecifierDependence D) :
     V ( translate(D, NNSDependence::UnexpandedPack, UnexpandedPack) |
             translate(D, NNSDependence::Instantiation, Instantiation) |
-            translate(D, NNSDependence::Dependent, Dependent)){}
+            translate(D, NNSDependence::Dependent, Dependent) |
+            translate(D, NNSDependence::Error, Error)) {}
 
   Dependence(TemplateArgumentDependence D)
       : V(translate(D, TADependence::UnexpandedPack, UnexpandedPack) |
           translate(D, TADependence::Instantiation, Instantiation) |
           translate(D, TADependence::Dependent, Dependent) |
           translate(D, TADependence::Error, Error)) {}
 
   Dependence(TemplateNameDependence D)
       : V(translate(D, TNDependence::UnexpandedPack, UnexpandedPack) |
              translate(D, TNDependence::Instantiation, Instantiation) |
-             translate(D, TNDependence::Dependent, Dependent)) {}
+             translate(D, TNDependence::Dependent, Dependent) |
+             translate(D, TNDependence::Error, Error)) {}
 
   TypeDependence type() const {
     return translate(V, UnexpandedPack, TypeDependence::UnexpandedPack) |
            translate(V, Instantiation, TypeDependence::Instantiation) |
            translate(V, Dependent, TypeDependence::Dependent) |
            translate(V, Error, TypeDependence::Error) |
            translate(V, VariablyModified, TypeDependence::VariablyModified);
   }
 
   ExprDependence expr() const {
     return translate(V, UnexpandedPack, ExprDependence::UnexpandedPack) |
            translate(V, Instantiation, ExprDependence::Instantiation) |
            translate(V, Type, ExprDependence::Type) |
            translate(V, Value, ExprDependence::Value) |
            translate(V, Error, ExprDependence::Error);
   }
 
   NestedNameSpecifierDependence nestedNameSpecifier() const {
     return translate(V, UnexpandedPack, NNSDependence::UnexpandedPack) |
            translate(V, Instantiation, NNSDependence::Instantiation) |
-           translate(V, Dependent, NNSDependence::Dependent);
+           translate(V, Dependent, NNSDependence::Dependent) |
+           translate(V, Error, NNSDependence::Error);
   }
 
   TemplateArgumentDependence templateArgument() const {
     return translate(V, UnexpandedPack, TADependence::UnexpandedPack) |
            translate(V, Instantiation, TADependence::Instantiation) |
            translate(V, Dependent, TADependence::Dependent) |
            translate(V, Error, TADependence::Error);
   }
 
   TemplateNameDependence templateName() const {
     return translate(V, UnexpandedPack, TNDependence::UnexpandedPack) |
            translate(V, Instantiation, TNDependence::Instantiation) |
-           translate(V, Dependent, TNDependence::Dependent);
+           translate(V, Dependent, TNDependence::Dependent) |
+           translate(V, Error, TNDependence::Error);
   }
 
 private:
   Bits V;
 
   template <typename T, typename U>
   static U translate(T Bits, T FromBit, U ToBit) {
     return (Bits & FromBit) ? ToBit : static_cast<U>(0);

clang/test/Sema/invalid-bitwidth-expr.mm

 
 auto func() {
   return undef(); // expected-error {{use of undeclared identifier}}
 }
 struct Y {
   int X : func();
 };
 constexpr int sss = sizeof(Y);
+
+bool Foo(int *); // expected-note {{candidate function not viable}}
+template <typename T>
+struct Base {};
+template <typename T>
+auto func() {
+  // error-bit should be propagated from TemplateArgument to NestNameSpecifier.
+  class Base<decltype(Foo(T()))>::type C; // expected-error {{no matching function for call to 'Foo'}}
+  return C;
+}
+struct Z {
+  int X : func<int>(); // expected-note {{in instantiation of function template}}
+};
+constexpr int ssss = sizeof(Z);