[AST] Fix dependence-bits for CXXDefaultInitExpr.

clang/include/clang/AST/ComputeDependence.h

 class SubstNonTypeTemplateParmExpr;
 class CoroutineSuspendExpr;
 class DependentCoawaitExpr;
 class CXXNewExpr;
 class CXXPseudoDestructorExpr;
 class OverloadExpr;
 class DependentScopeDeclRefExpr;
 class CXXConstructExpr;
+class CXXDefaultInitExpr;
 class LambdaExpr;
 class CXXUnresolvedConstructExpr;
 class CXXDependentScopeMemberExpr;
 class MaterializeTemporaryExpr;
 class CXXFoldExpr;
 class TypeTraitExpr;
 class ConceptSpecializationExpr;
 class PredefinedExpr;

 ExprDependence computeDependence(DependentCoawaitExpr *E);
 ExprDependence computeDependence(CXXNewExpr *E);
 ExprDependence computeDependence(CXXPseudoDestructorExpr *E);
 ExprDependence computeDependence(OverloadExpr *E, bool KnownDependent,
                                  bool KnownInstantiationDependent,
                                  bool KnownContainsUnexpandedParameterPack);
 ExprDependence computeDependence(DependentScopeDeclRefExpr *E);
 ExprDependence computeDependence(CXXConstructExpr *E);
+ExprDependence computeDependence(CXXDefaultInitExpr *E);
 ExprDependence computeDependence(LambdaExpr *E,
                                  bool ContainsUnexpandedParameterPack);
 ExprDependence computeDependence(CXXUnresolvedConstructExpr *E);
 ExprDependence computeDependence(CXXDependentScopeMemberExpr *E);
 ExprDependence computeDependence(MaterializeTemporaryExpr *E);
 ExprDependence computeDependence(CXXFoldExpr *E);
 ExprDependence computeDependence(TypeTraitExpr *E);
 ExprDependence computeDependence(ConceptSpecializationExpr *E,

clang/lib/AST/ComputeDependence.cpp

 
 ExprDependence clang::computeDependence(CXXConstructExpr *E) {
   auto D = toExprDependence(E->getType()->getDependence());
   for (auto *A : E->arguments())
     D |= A->getDependence() & ~ExprDependence::Type;
   return D;
 }
 
+ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) {
+  return E->getExpr()->getDependence();
+}
+
 ExprDependence clang::computeDependence(LambdaExpr *E,
                                         bool ContainsUnexpandedParameterPack) {
   auto D = toExprDependence(E->getType()->getDependence());
   if (ContainsUnexpandedParameterPack)
     D |= ExprDependence::UnexpandedPack;
   return D;
 }
 

clang/lib/AST/ExprCXX.cpp

: Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
            Ty->isLValueReferenceType()
                ? VK_LValue
                : Ty->isRValueReferenceType() ? VK_XValue : VK_RValue,
            /*FIXME*/ OK_Ordinary),
       Field(Field), UsedContext(UsedContext) {
   CXXDefaultInitExprBits.Loc = Loc;
   assert(Field->hasInClassInitializer());
 
-  setDependence(ExprDependence::None);
+  setDependence(computeDependence(this));
 }
 
 CXXTemporary *CXXTemporary::Create(const ASTContext &C,
                                    const CXXDestructorDecl *Destructor) {
   return new (C) CXXTemporary(Destructor);
 }
 
 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C,

clang/test/SemaCXX/invalid-constructor-init.cpp

 // RUN: %clang_cc1 -frecovery-ast -verify %s
 
 struct X {
   int Y;
   constexpr X() // expected-error {{constexpr constructor never produces}}
       : Y(foo()) {} // expected-error {{use of undeclared identifier 'foo'}}
 };
 // no crash on evaluating the constexpr ctor.
 constexpr int Z = X().Y; // expected-error {{constexpr variable 'Z' must be initialized by a constant expression}}
 
 struct X2 {
-  int Y = foo();    // expected-error {{use of undeclared identifier 'foo'}} \
-                 // expected-note {{subexpression not valid in a constant expression}}
+  int Y = foo();    // expected-error {{use of undeclared identifier 'foo'}}
   constexpr X2() {} // expected-error {{constexpr constructor never produces a constant expression}}
 };
 
 struct X3 {
   int Y;
   constexpr X3() // expected-error {{constexpr constructor never produces}}
       : Y(({foo();})) {} // expected-error {{use of undeclared identifier 'foo'}}
 };
 
 struct CycleDelegate {
   int Y;
   CycleDelegate(int)
       : Y(foo()) {} // expected-error {{use of undeclared identifier 'foo'}}
   // no bogus "delegation cycle" diagnostic
   CycleDelegate(float) : CycleDelegate(1) {}
 };
+
+struct X4 {
+  int* p = new int(invalid()); // expected-error {{use of undeclared identifier}}
+};
+// no crash on evaluating the CXXDefaultInitExpr.
+constexpr int* s = X4().p; // expected-error {{must be initialized by}}