[clang][wip] Better handling of dependent lambda.This is an attempt to fix GH62916.However, it breaks GH57960I seem unable to find something that works for both issues.

[cor3ntin]

@erichkeane suggested we should not try to transform the body of the lambda at all, which may be a better approach.

clang/lib/Sema/SemaTemplateInstantiate.cpp

ExprResult TransformLambdaExpr(LambdaExpr *E) {
           if (ErrorResult.isUsable())
             PVD->setDefaultArg(ErrorResult.get());
         }
       }
 
       return Result;
     }
 
+    bool LambdaExpressionShouldBeConsideredDependent(LambdaExpr * E) const {
+      if(E->getLambdaClass()->isNeverDependentLambda())
+        return false;
+
+      if(SemaRef.CurContext->isDependentContext())
+        return true;
+
+      return llvm::any_of(TemplateArgs.getInnermost(), [](const TemplateArgument & C) {
+        return C.isDependent();
+      });
+
+    }
+
+
     ExprResult TransformRequiresExpr(RequiresExpr *E) {
       LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
       ExprResult TransReq = inherited::TransformRequiresExpr(E);
       if (TransReq.isInvalid())
         return TransReq;
       assert(TransReq.get() != E &&
              "Do not change value of isSatisfied for the existing expression. "
              "Create a new expression instead.");

clang/lib/Sema/TreeTransform.h

ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                           bool ExpectParameterPack);
 
   /// Transform the body of a lambda-expression.
   StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
   /// Alternative implementation of TransformLambdaBody that skips transforming
   /// the body.
   StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);
 
+  bool LambdaExpressionShouldBeConsideredDependent(LambdaExpr *E) const;
+
   QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
 
   StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
   ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
 
   TemplateParameterList *TransformTemplateParameterList(
         TemplateParameterList *TPL) {
     return TPL;
for (LambdaExpr::capture_iterator C = E->capture_begin(),
     }
   }
 
   LambdaScopeInfo *LSI = getSema().PushLambdaScope();
   Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
 
   // Create the local class that will describe the lambda.
 
-  // FIXME: DependencyKind below is wrong when substituting inside a templated
-  // context that isn't a DeclContext (such as a variable template), or when
-  // substituting an unevaluated lambda inside of a function's parameter's type
-  // - as parameter types are not instantiated from within a function's DC. We
-  // use evaluation contexts to distinguish the function parameter case.
   CXXRecordDecl::LambdaDependencyKind DependencyKind =
-      CXXRecordDecl::LDK_Unknown;
-  if ((getSema().isUnevaluatedContext() ||
-       getSema().isConstantEvaluatedContext()) &&
-      (getSema().CurContext->isFileContext() ||
-       !getSema().CurContext->getParent()->isDependentContext()))
-    DependencyKind = CXXRecordDecl::LDK_NeverDependent;
+      getDerived().LambdaExpressionShouldBeConsideredDependent(E) ?
+      CXXRecordDecl::LDK_AlwaysDependent : CXXRecordDecl::LDK_NeverDependent;
 
   CXXRecordDecl *OldClass = E->getLambdaClass();
   CXXRecordDecl *Class = getSema().createLambdaClosureType(
       E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind,
       E->getCaptureDefault());
   getDerived().transformedLocalDecl(OldClass, {Class});
 
   CXXMethodDecl *NewCallOperator =
for (LambdaExpr::capture_iterator C = E->capture_begin(),
     // Capture the transformed variable.
     getSema().tryCaptureVariable(CapturedVar, C->getLocation());
   }
 
   return S;
 }
 
 template<typename Derived>
+bool TreeTransform<Derived>::LambdaExpressionShouldBeConsideredDependent(LambdaExpr *) const {
+  return false;
+}
+
+
+template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
                                                   CXXUnresolvedConstructExpr *E) {
   TypeSourceInfo *T =
       getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
   if (!T)
     return ExprError();
 

clang/test/SemaCXX/lambda-expressions.cpp

 // be properly handled after D124351
 constexpr int i = 2;
 void foo() {
   (void)[=][[gnu::aligned(i)]] () {}; // expected-warning{{C++23 extension}}
   // CHECK: AlignedAttr
   // CHECK-NEXT: ConstantExpr
   // CHECK-NEXT: value: Int 2
 }
+
+#if __cplusplus > 201402L
+namespace GH62916 {
+
+template <class T, int U = []() -> int { return T(42); }()>
+struct P {
+    static constexpr int value = U;
+};
+
+template <class T>
+constexpr P<T> foo() {
+    return {};
+}
+
+void test() {
+  static_assert(foo<int>().value == 42);
+}
+
+}
+#endif