Fix for assertion failure on PR46865

[Sunil_Srivastava]

Summary

This is a proposed fix for the crash of PR46865.

[wristow]

clang/lib/AST/ExprConstant.cpp

3098

This looks like a more appropriate assertion-check to me. But it's out of my area of experience, so I don't feel qualified to give an authoritative "LGTM".

[rsmith]

I think the assertion is correct: if we reach this point, then we have a DeclRefExpr that is not value-dependent and refers to a declaration whose initializer is value-dependent. That should never happen if the variable's type satisfies the requirements for use in a constant expression, which is what mightBeUsableInConstantExpressions checks.

The bug here appears to be that the dependency bits on a DeclRefExpr are computed too early when it refers to a templated variable -- before we instantiate the initializer -- and don't get "fixed" later when the initializer is instantiated. DoMarkVarDeclReferenced would be the right place to handle this -- after we trigger instantiation of the initializer, we should recompute the dependence bits on the DeclRefExpr, because they can depend on the initializer.

clang/lib/AST/ExprConstant.cpp

static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
   }
 
   if (Init->isValueDependent()) {
     // The DeclRefExpr is not value-dependent, but the variable it refers to
     // has a value-dependent initializer. This should only happen in
     // constant-folding cases, where the variable is not actually of a suitable
     // type for use in a constant expression (otherwise the DeclRefExpr would
     // have been value-dependent too), so diagnose that.
-    assert(!VD->mightBeUsableInConstantExpressions(Info.Ctx));
+    assert(!VD->isUsableInConstantExpressions(Info.Ctx));
     if (!Info.checkingPotentialConstantExpression()) {
       Info.FFDiag(E, Info.getLangOpts().CPlusPlus11
                          ? diag::note_constexpr_ltor_non_constexpr
                          : diag::note_constexpr_ltor_non_integral, 1)
           << VD << VD->getType();
       Info.Note(VD->getLocation(), diag::note_declared_at);
     }
     return false;

clang/test/AST/pr46865.cpp

+// RUN: %clang_cc1 -fsyntax-only %s
+typedef unsigned long size_t;
+
+namespace std {
+template<class _Ty> struct add_const { typedef const _Ty type; };
+
+template<class A, class B> class tuple {A a; B b; };
+template<class _Tuple> struct tuple_size;
+template<class _Tuple> struct tuple_size<const _Tuple> {static constexpr size_t value = 2;}; // hardcoded 2
+
+template<size_t _Index, class _Tuple> struct tuple_element;
+template<class _This, class _that> struct tuple_element<0, tuple<_This, _that> > { typedef _This type; };
+template<class _This, class _that> struct tuple_element<1, tuple<_This, _that> > { typedef _that type; };
+
+template<size_t _Index, class _Tuple> struct tuple_element<_Index, const _Tuple> {
+ typedef tuple_element<_Index, _Tuple> _Mybase;
+ typedef typename add_const<typename _Mybase::type>::type type;
+};
+
+template<size_t _Index, class A, class B> inline constexpr const typename tuple_element<_Index, tuple<A, B> >::type& 
+      get(const tuple<A, B>& _Tuple) noexcept {}
+
+template<class A, class B> inline constexpr const typename tuple_element<0, tuple<A, B> >::type& 
+      get(const tuple<A, B>& _Tuple) noexcept { return _Tuple.a; }
+template<class A, class B> inline constexpr const typename tuple_element<1, tuple<A, B> >::type& 
+      get(const tuple<A, B>& _Tuple) noexcept { return _Tuple.b; }
+}
+std::tuple<unsigned,unsigned> inline __attribute__((always_inline)) get_sc(unsigned v) {}
+              
+template <typename T> class bbb {
+  unsigned u;
+  inline __attribute__((always_inline)) void cebb();
+};
+
+template <typename T> void bbb<T>::cebb() 
+{
+  unsigned p;
+  auto const t = u;
+  auto const [s, c] = get_sc(t);
+  p = s;
+}
+