[Clang] Fix Unevaluated Lambdas

[cor3ntin]

Summary

Unlike other types, when lambdas are instanciated,
they are recreated from scratch.
When an unevaluated lambdas appear in the type of a function,
parameter it is instanciated in the wrong declaration context,
as parameters are transformed before the function.

To support lambda in function parameters, we try to
compute whether they are dependant without looking at the
declaration context.

This is a short term stopgap solution to avoid clang
iceing. A better fix might be to inject some kind of
transparent declaration with correctly computed dependency
for function parameters, variable templates, etc.

Fixes https://github.com/llvm/llvm-project/issues/50376
Fixes https://github.com/llvm/llvm-project/issues/51414
Fixes https://github.com/llvm/llvm-project/issues/51416
Fixes https://github.com/llvm/llvm-project/issues/51641
Fixes https://github.com/llvm/llvm-project/issues/54296

[aaron.ballman]

Adding Erich to look at this WIP for early feedback as he's recently been looking at template instantiation guts rather deeply, but I added some questions.

clang/include/clang/AST/DeclCXX.h

280–282

(Matches the naming style used just above.)

clang/lib/Sema/TreeTransform.h

12934

12952

Can you explain why you only do these transformations when the old class is a dependent context? Also, should this be looking at getDerived().AlwaysRebuild()? I'm not certain -- we're not calling any Rebuild* functions here because lambdas are not rebuilt but generated entirely from scratch. So I'm guessing we don't need to look at AlwaysRebuild, but it's a bit unclear.

12968–12969

Are these changes necessary as part of this patch? I'm a bit worried that only doing this in dependent contexts may change behavior for code like this: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp#L769

13037

This also seems a bit surprising -- can't the variable declaration be non-templated but still dependent (e.g., an auto variable whose initialization is dependent?)

[cor3ntin]

clang/lib/Sema/TreeTransform.h

12952

I was trying to fix some crashes at some point, Not sure that's still needed anymore, I have to check. I suspect you might be right.

[cor3ntin]

Remove prior attempt at fixing this bug (good catch Aaron!)

[shafik]

Can you add a test to ASTImpoterTest.cpp that checks that we import the LambdaDependencyKind correctly?

[cor3ntin]

In D121532#3380580, @shafik wrote:

Can you add a test to ASTImpoterTest.cpp that checks that we import the LambdaDependencyKind correctly?

Sure, if we agree that the direction is sufficiently palatable (I'm not convince it is yet), I can add such a test (and more generally cleanup the test)

[aaron.ballman]

clang/lib/Sema/SemaLambda.cpp

978–979

I don't think we should pass KnownDependent here as a bool, despite it working because of the enumerator value for the known dependent case.

[cor3ntin]

• Added a couple of tests in ASTImporterTest.cpp
• Rename elements of LambdaDependencyKind
• Fix ActOnStartOfLambdaDefinition to not use a boolean for

LambdaDependencyKind.

[cor3ntin]

Formatting.

[aaron.ballman]

I think this is a sufficient stopgap measure to keep clang from crashing, and I appreciate the FIXME comment. Should the cxx_status page also be updated, or is P0315R4 still partial (and if it is, can we add information to the status page about what's partial if you know it)? Also, this could use a release note about the fixes. So almost LGTM!

clang/lib/Sema/TreeTransform.h

12934

Still need to fix the typos here.

[erichkeane]

Don't forget about Release notes!

[cor3ntin]

• Fix a typo (sorry Aaron, I completely missed that)
• Add a release note
• Clarify why the implementation status is still partial.

This is a bit of a drive-by change but I agree it's a good thing
to clarify.

[aaron.ballman]

LGTM!

[shafik]

@cor3ntin I wonder if these asserts are due to the partial implementation here: https://github.com/llvm/llvm-project/issues/57960

I am happy to look into it if you can point me in the right direction.

clang/include/clang/AST/DeclCXX.h

enum SpecialMemberFlags {
     SMF_CopyConstructor = 0x2,
     SMF_MoveConstructor = 0x4,
     SMF_CopyAssignment = 0x8,
     SMF_MoveAssignment = 0x10,
     SMF_Destructor = 0x20,
     SMF_All = 0x3f
   };
 
+public:
+  enum LambdaDependencyKind {
+    LDKUnknown = 0,
+    LDKAlwaysDependent,
+    LDKNeverDependent,
+  };
+
+private:
   struct DefinitionData {
     #define FIELD(Name, Width, Merge) \
     unsigned Name : Width;
     #include "CXXRecordDeclDefinitionBits.def"
 
     /// Whether this class describes a C++ lambda.
     unsigned IsLambda : 1;
 
struct LambdaDefinitionData : public DefinitionData {
     /// Whether this lambda is known to be dependent, even if its
     /// context isn't dependent.
     ///
     /// A lambda with a non-dependent context can be dependent if it occurs
     /// within the default argument of a function template, because the
     /// lambda will have been created with the enclosing context as its
     /// declaration context, rather than function. This is an unfortunate
     /// artifact of having to parse the default arguments before.
-    unsigned Dependent : 1;
+    unsigned DependencyKind : 2;
 
     /// Whether this lambda is a generic lambda.
     unsigned IsGenericLambda : 1;
 
     /// The Default Capture.
     unsigned CaptureDefault : 2;
 
     /// The number of captures in this lambda is limited 2^NumCaptures.
struct LambdaDefinitionData : public DefinitionData {
 
     /// The list of captures, both explicit and implicit, for this
     /// lambda.
     Capture *Captures = nullptr;
 
     /// The type of the call method.
     TypeSourceInfo *MethodTyInfo;
 
-    LambdaDefinitionData(CXXRecordDecl *D, TypeSourceInfo *Info, bool Dependent,
+    LambdaDefinitionData(CXXRecordDecl *D, TypeSourceInfo *Info, unsigned DK,
                          bool IsGeneric, LambdaCaptureDefault CaptureDefault)
-        : DefinitionData(D), Dependent(Dependent), IsGenericLambda(IsGeneric),
+        : DefinitionData(D), DependencyKind(DK), IsGenericLambda(IsGeneric),
           CaptureDefault(CaptureDefault), NumCaptures(0),
           NumExplicitCaptures(0), HasKnownInternalLinkage(0), ManglingNumber(0),
           MethodTyInfo(Info) {
       IsLambda = true;
 
       // C++1z [expr.prim.lambda]p4:
       //   This class type is not an aggregate type.
       Aggregate = false;
public:
 
   static CXXRecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                                SourceLocation StartLoc, SourceLocation IdLoc,
                                IdentifierInfo *Id,
                                CXXRecordDecl *PrevDecl = nullptr,
                                bool DelayTypeCreation = false);
   static CXXRecordDecl *CreateLambda(const ASTContext &C, DeclContext *DC,
                                      TypeSourceInfo *Info, SourceLocation Loc,
-                                     bool DependentLambda, bool IsGeneric,
+                                     unsigned DependencyKind, bool IsGeneric,
                                      LambdaCaptureDefault CaptureDefault);
   static CXXRecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
 
   bool isDynamicClass() const {
     return data().Polymorphic || data().NumVBases != 0;
   }
 
   /// @returns true if class is dynamic or might be dynamic because the

   /// This flag is a workaround for an issue with parsing, where default
   /// arguments are parsed before their enclosing function declarations have
   /// been created. This means that any lambda expressions within those
   /// default arguments will have as their DeclContext the context enclosing
   /// the function declaration, which may be non-dependent even when the
   /// function declaration itself is dependent. This flag indicates when we
   /// know that the lambda is dependent despite that.
   bool isDependentLambda() const {
-    return isLambda() && getLambdaData().Dependent;
+    return isLambda() && getLambdaData().DependencyKind == LDKAlwaysDependent;
+  }
+
+  bool isNeverDependentLambda() const {
+    return isLambda() && getLambdaData().DependencyKind == LDKNeverDependent;
+  }
+
+  unsigned getLambdaDependencyKind() const {
+    if (!isLambda())
+      return LDKUnknown;
+    return getLambdaData().DependencyKind;
   }
 
   TypeSourceInfo *getLambdaTypeInfo() const {
     return getLambdaData().MethodTyInfo;
   }
 
   // Determine whether this type is an Interface Like type for
   // __interface inheritance purposes.

clang/include/clang/Sema/Sema.h

public:
 
   /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
   /// initializer for the declaration 'Dcl'.
   void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
 
   /// Create a new lambda closure type.
   CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
                                          TypeSourceInfo *Info,
-                                         bool KnownDependent,
+                                         unsigned LambdaDependencyKind,
                                          LambdaCaptureDefault CaptureDefault);
 
   /// Start the definition of a lambda expression.
   CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
                                        SourceRange IntroducerRange,
                                        TypeSourceInfo *MethodType,
                                        SourceLocation EndLoc,
                                        ArrayRef<ParmVarDecl *> Params,

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
   CXXRecordDecl *D2CXX = nullptr;
   if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
     if (DCXX->isLambda()) {
       auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
       if (!TInfoOrErr)
         return TInfoOrErr.takeError();
       if (GetImportedOrCreateSpecialDecl(
               D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
-              DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(),
+              DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
               DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
         return D2CXX;
       ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl());
       if (!CDeclOrErr)
         return CDeclOrErr.takeError();
       D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr,
                                DCXX->hasKnownLambdaInternalLinkage());
       D2CXX->setDeviceLambdaManglingNumber(

clang/lib/AST/DeclBase.cpp

if (isa<ClassTemplatePartialSpecializationDecl>(this))
     return true;
 
   if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) {
     if (Record->getDescribedClassTemplate())
       return true;
 
     if (Record->isDependentLambda())
       return true;
+    if (Record->isNeverDependentLambda())
+      return false;
   }
 
   if (const auto *Function = dyn_cast<FunctionDecl>(this)) {
     if (Function->getDescribedFunctionTemplate())
       return true;
 
     // Friend function declarations are dependent if their *lexical*
     // context is dependent.

clang/lib/AST/DeclCXX.cpp

CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
   if (!DelayTypeCreation)
     C.getTypeDeclType(R, PrevDecl);
   return R;
 }
 
 CXXRecordDecl *
 CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
                             TypeSourceInfo *Info, SourceLocation Loc,
-                            bool Dependent, bool IsGeneric,
+                            unsigned DependencyKind, bool IsGeneric,
                             LambdaCaptureDefault CaptureDefault) {
   auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
                                       nullptr, nullptr);
   R->setBeingDefined(true);
-  R->DefinitionData =
-      new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
-                                          CaptureDefault);
+  R->DefinitionData = new (C) struct LambdaDefinitionData(
+      R, Info, DependencyKind, IsGeneric, CaptureDefault);
   R->setMayHaveOutOfDateDef(false);
   R->setImplicit(true);
+
   C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
   return R;
 }
 
 CXXRecordDecl *
 CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
   auto *R = new (C, ID) CXXRecordDecl(
       CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),

clang/lib/Sema/SemaLambda.cpp

LSI->GLTemplateParameterList = TemplateParameterList::Create(
         /*L angle loc*/ LSI->ExplicitTemplateParamsRange.getBegin(),
         LSI->TemplateParams,
         /*R angle loc*/LSI->ExplicitTemplateParamsRange.getEnd(),
         LSI->RequiresClause.get());
   }
   return LSI->GLTemplateParameterList;
 }
 
-CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange,
-                                             TypeSourceInfo *Info,
-                                             bool KnownDependent,
-                                             LambdaCaptureDefault CaptureDefault) {
+CXXRecordDecl *
+Sema::createLambdaClosureType(SourceRange IntroducerRange, TypeSourceInfo *Info,
+                              unsigned LambdaDependencyKind,
   DeclContext *DC = CurContext;
   while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext()))
     DC = DC->getParent();
   bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(),
                                                                *this);
   // Start constructing the lambda class.
-  CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, Info,
-                                                     IntroducerRange.getBegin(),
-                                                     KnownDependent,
-                                                     IsGenericLambda,
-                                                     CaptureDefault);
+  CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(
+      Context, DC, Info, IntroducerRange.getBegin(), LambdaDependencyKind,
+      IsGenericLambda, CaptureDefault);
   DC->addDecl(Class);
 
   return Class;
 }
 
 /// Determine whether the given context is or is enclosed in an inline
 /// function.
 static bool isInInlineFunction(const DeclContext *DC) {
if (ParamInfo.getNumTypeObjects() == 0) {
     }
 
     // Check for unexpanded parameter packs in the method type.
     if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
       DiagnoseUnexpandedParameterPack(Intro.Range.getBegin(), MethodTyInfo,
                                       UPPC_DeclarationType);
   }
 
   CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo,
                                                  KnownDependent, Intro.Default);
   CXXMethodDecl *Method =
       startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params,
                             ParamInfo.getDeclSpec().getConstexprSpecifier(),
                             ParamInfo.getTrailingRequiresClause());
   if (ExplicitParams)
     CheckCXXDefaultArguments(Method);
 
   // This represents the function body for the lambda function, check if we

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
     PrevDecl = cast<CXXRecordDecl>(Prev);
   }
 
   CXXRecordDecl *Record = nullptr;
   bool IsInjectedClassName = D->isInjectedClassName();
   if (D->isLambda())
     Record = CXXRecordDecl::CreateLambda(
         SemaRef.Context, Owner, D->getLambdaTypeInfo(), D->getLocation(),
-        D->isDependentLambda(), D->isGenericLambda(),
+        D->getLambdaDependencyKind(), D->isGenericLambda(),
         D->getLambdaCaptureDefault());
   else
     Record = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
                                    D->getBeginLoc(), D->getLocation(),
                                    D->getIdentifier(), PrevDecl,
                                    /*DelayTypeCreation=*/IsInjectedClassName);
   // Link the type of the injected-class-name to that of the outer class.
   if (IsInjectedClassName)

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
   // Transform the trailing requires clause
   ExprResult NewTrailingRequiresClause;
   if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause())
     // FIXME: Concepts: Substitution into requires clause should only happen
     //                  when checking satisfaction.
     NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
 
   // Create the local class that will describe the lambda.
-  // FIXME: KnownDependent below is wrong when substituting inside a templated
-  // context that isn't a DeclContext (such as a variable template).
+
+  // 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 type are not instanciated from within a function's DC. We
+  // use isUnevaluatedContext() to distinguish the function parameter case.
+  CXXRecordDecl::LambdaDependencyKind DependencyKind =
+      CXXRecordDecl::LDKUnknown;
+  if (getSema().isUnevaluatedContext() &&
+      (getSema().CurContext->isFileContext() ||
+       !getSema().CurContext->getParent()->isDependentContext()))
+    DependencyKind = CXXRecordDecl::LDKNeverDependent;
+
   CXXRecordDecl *OldClass = E->getLambdaClass();
-  CXXRecordDecl *Class
-    = getSema().createLambdaClosureType(E->getIntroducerRange(),
-                                        NewCallOpTSI,
-                                        /*KnownDependent=*/false,
-                                        E->getCaptureDefault());
+  CXXRecordDecl *Class =
+      getSema().createLambdaClosureType(E->getIntroducerRange(), NewCallOpTSI,
+                                        DependencyKind, E->getCaptureDefault());
+
   getDerived().transformedLocalDecl(OldClass, {Class});
 
   Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling;
   if (getDerived().ReplacingOriginal())
     Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(),
                                OldClass->getLambdaManglingNumber(),
                                OldClass->getDeviceLambdaManglingNumber(),
                                OldClass->getLambdaContextDecl());
 
   // Build the call operator.
   CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
       Class, E->getIntroducerRange(), NewCallOpTSI,
       E->getCallOperator()->getEndLoc(),
       NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
       E->getCallOperator()->getConstexprKind(),
       NewTrailingRequiresClause.get());
 
   LSI->CallOperator = NewCallOperator;
 
   getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
   getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
 
   // Number the lambda for linkage purposes if necessary.
   getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling);
 
   // Introduce the context of the call operator.
   Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
                                  /*NewThisContext*/false);
 
   // Enter the scope of the lambda.
if (E->isInitCapture(C)) {
         }
         NewVDs.push_back(NewVD);
         getSema().addInitCapture(LSI, NewVD);
       }
 
       if (Invalid)
         break;
 
       getDerived().transformedLocalDecl(OldVD, NewVDs);
       continue;
     }
 
     assert(C->capturesVariable() && "unexpected kind of lambda capture");
 
     // Determine the capture kind for Sema.
     Sema::TryCaptureKind Kind
       = C->isImplicit()? Sema::TryCapture_Implicit

clang/lib/Serialization/ASTReaderDecl.cpp

if (Data.ComputedVisibleConversions)
     Record.readUnresolvedSet(Data.VisibleConversions);
   assert(Data.Definition && "Data.Definition should be already set!");
   Data.FirstFriend = readDeclID();
 
   if (Data.IsLambda) {
     using Capture = LambdaCapture;
 
     auto &Lambda = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
-    Lambda.Dependent = Record.readInt();
+    Lambda.DependencyKind = Record.readInt();
     Lambda.IsGenericLambda = Record.readInt();
     Lambda.CaptureDefault = Record.readInt();
     Lambda.NumCaptures = Record.readInt();
     Lambda.NumExplicitCaptures = Record.readInt();
     Lambda.HasKnownInternalLinkage = Record.readInt();
     Lambda.ManglingNumber = Record.readInt();
     D->setDeviceLambdaManglingNumber(Record.readInt());
     Lambda.ContextDecl = readDeclID();

 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update) {
   struct CXXRecordDecl::DefinitionData *DD;
   ASTContext &C = Reader.getContext();
 
   // Determine whether this is a lambda closure type, so that we can
   // allocate the appropriate DefinitionData structure.
   bool IsLambda = Record.readInt();
   if (IsLambda)
-    DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
-                                                     LCD_None);
+    DD = new (C) CXXRecordDecl::LambdaDefinitionData(
+        D, nullptr, CXXRecordDecl::LDKUnknown, false, LCD_None);
   else
     DD = new (C) struct CXXRecordDecl::DefinitionData(D);
 
   CXXRecordDecl *Canon = D->getCanonicalDecl();
   // Set decl definition data before reading it, so that during deserialization
   // when we read CXXRecordDecl, it already has definition data and we don't
   // set fake one.
   if (!Canon->DefinitionData)

clang/lib/Serialization/ASTWriter.cpp

void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) {
   if (Data.ComputedVisibleConversions)
     AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context));
   // Data.Definition is the owning decl, no need to write it.
   AddDeclRef(D->getFirstFriend());
 
   // Add lambda-specific data.
   if (Data.IsLambda) {
     auto &Lambda = D->getLambdaData();
-    Record->push_back(Lambda.Dependent);
+    Record->push_back(Lambda.DependencyKind);
     Record->push_back(Lambda.IsGenericLambda);
     Record->push_back(Lambda.CaptureDefault);
     Record->push_back(Lambda.NumCaptures);
     Record->push_back(Lambda.NumExplicitCaptures);
     Record->push_back(Lambda.HasKnownInternalLinkage);
     Record->push_back(Lambda.ManglingNumber);
     Record->push_back(D->getDeviceLambdaManglingNumber());
     AddDeclRef(D->getLambdaContextDecl());

clang/test/SemaCXX/lambda-unevaluated.cpp

 int unique_test1();
 static_assert(&unique_test1<[](){}> != &unique_test1<[](){}>);
 
 template <class T>
 auto g(T) -> decltype([]() { T::invalid; } ());
 auto e = g(0); // expected-error{{no matching function for call}}
 // expected-note@-2 {{substitution failure}}
 
+template <typename T>
+auto foo(decltype([] {
+  return [] { return T(); }();
+})) {}
+
+void test() {
+  foo<int>({});
+}
+
+template <typename T>
+struct C {
+  template <typename U>
+  auto foo(decltype([] {
+    return [] { return T(); }();
+  })) {}
+};
+
+void test2() {
+  C<int>{}.foo<long>({});
+}
+
 namespace PR52073 {
 // OK, these are distinct functions not redefinitions.
 template<typename> void f(decltype([]{})) {} // expected-note {{candidate}}
 template<typename> void f(decltype([]{})) {} // expected-note {{candidate}}
 void use_f() { f<int>({}); } // expected-error {{ambiguous}}
 
 // Same.
 template<int N> void g(const char (*)[([]{ return N; })()]) {} // expected-note {{candidate}}
 template<int N> void g(const char (*)[([]{ return N; })()]) {} // expected-note {{candidate}}
 // FIXME: We instantiate the lambdas into the context of the function template,
-// so we think they're dependent and can't evaluate a call to them.
+//  so we think they're dependent and can't evaluate a call to them.
 void use_g() { g<6>(&"hello"); } // expected-error {{no matching function}}
 }
+
+namespace GH51416 {
+
+template <class T>
+struct A {
+  void spam(decltype([] {}));
+};
+
+template <class T>
+void A<T>::spam(decltype([] {})) // expected-error{{out-of-line definition of 'spam' does not match}}
+{}
+
+struct B {
+  template <class T>
+  void spam(decltype([] {}));
+};
+
+template <class T>
+void B::spam(decltype([] {})) {} // expected-error{{out-of-line definition of 'spam' does not match}}
+
+} // namespace GH51416
+
+namespace GH50376 {
+
+template <typename T, typename Fn>
+struct foo_t {    // expected-note 2{{candidate constructor}}
+  foo_t(T ptr) {} // expected-note{{candidate constructor}}
+};
+
+template <typename T>
+using alias = foo_t<T, decltype([](int) { return 0; })>;
+
+template <typename T>
+auto fun(T const &t) -> alias<T> {
+  return alias<T>{t}; // expected-error{{no viable conversion from returned value of type 'alias<...>'}}
+}
+
+void f() {
+  int i;
+  auto const error = fun(i); // expected-note{{in instantiation}}
+}
+
+} // namespace GH50376
+
+namespace GH51414 {
+template <class T> void spam(decltype([] {}) (*s)[sizeof(T)] = nullptr) {}
+void foo() {
+  spam<int>();
+}
+} // namespace GH51414
+
+namespace GH51641 {
+template <class T>
+void foo(decltype(+[](T) {}) lambda, T param);
+static_assert(!__is_same(decltype(foo<int>), void));
+} // namespace GH51641