[clang] fix linkage of nested lambda

[blastrock]

Summary

This is an attempt to fix https://bugs.llvm.org/show_bug.cgi?id=44368

This effectively reverts D1783. It doesn't break the current tests and fixes the test that this commit adds.

We now decide of a lambda linkage only depending on the visibility of its parent context.

[hliao]

+ rsmith

clang/lib/AST/Decl.cpp

1416–1417

The code is still inconsistent with the comment. Record is the lambda itself instead of the parent of the lambda.

[rsmith]

This is effectively reverting https://reviews.llvm.org/D1783. If we don't need that any more for whatever reason, can we also get rid of the check for whether the outermost lambda has a mangling number a few lines above? (Please also check if we can remove getOutermostEnclosingLambda, which was added for this purpose.)

clang/lib/AST/Decl.cpp

1416–1417

Record->getDeclContext() returns the parent of the lambda.

[blastrock]

Thank you for the answers.

I have removed all the outermost lambda code and tests still pass.

[hliao]

LGTM, but need @rsmith for the final review

[blastrock]

Thanks for the reviews! I do not have commit access, so please merge this whenever you can.

[hliao]

In D73701#1864136, @blastrock wrote:

Thanks for the reviews! I do not have commit access, so please merge this whenever you can.

done in 2926917f430. thanks for the patch!

clang/lib/AST/Decl.cpp

if (const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
     }
   }
   if (!isExternallyVisible(LV.getLinkage()))
     return LinkageInfo::none();
   return LinkageInfo(VisibleNoLinkage, LV.getVisibility(),
                      LV.isVisibilityExplicit());
 }
 
-static inline const CXXRecordDecl*
-getOutermostEnclosingLambda(const CXXRecordDecl *Record) {
-  const CXXRecordDecl *Ret = Record;
-  while (Record && Record->isLambda()) {
-    Ret = Record;
-    if (!Record->getParent()) break;
-    // Get the Containing Class of this Lambda Class
-    Record = dyn_cast_or_null<CXXRecordDecl>(
-      Record->getParent()->getParent());
-  }
-  return Ret;
-}
-
 LinkageInfo LinkageComputer::computeLVForDecl(const NamedDecl *D,
                                               LVComputationKind computation,
                                               bool IgnoreVarTypeLinkage) {
   // Internal_linkage attribute overrides other considerations.
   if (D->hasAttr<InternalLinkageAttr>())
     return getInternalLinkageFor(D);
 
   // Objective-C: treat all Objective-C declarations as having external
case Decl::CXXRecord: {
       const auto *Record = cast<CXXRecordDecl>(D);
       if (Record->isLambda()) {
         if (Record->hasKnownLambdaInternalLinkage() ||
             !Record->getLambdaManglingNumber()) {
           // This lambda has no mangling number, so it's internal.
           return getInternalLinkageFor(D);
         }
 
-        // This lambda has its linkage/visibility determined:
-        //  - either by the outermost lambda if that lambda has no mangling
-        //    number.
-        //  - or by the parent of the outer most lambda
-        // This prevents infinite recursion in settings such as nested lambdas
-        // used in NSDMI's, for e.g.
-        //  struct L {
-        //    int t{};
-        //    int t2 = ([](int a) { return [](int b) { return b; };})(t)(t);
-        //  };
-        const CXXRecordDecl *OuterMostLambda =
-            getOutermostEnclosingLambda(Record);
-        if (OuterMostLambda->hasKnownLambdaInternalLinkage() ||
-            !OuterMostLambda->getLambdaManglingNumber())
-          return getInternalLinkageFor(D);
-
         return getLVForClosure(
-                  OuterMostLambda->getDeclContext()->getRedeclContext(),
-                  OuterMostLambda->getLambdaContextDecl(), computation);
+                  Record->getDeclContext()->getRedeclContext(),
+                  Record->getLambdaContextDecl(), computation);
       }
 
       break;
     }
   }
 
   // Handle linkage for namespace-scope names.
   if (D->getDeclContext()->getRedeclContext()->isFileContext())
LinkageInfo LinkageComputer::computeLVForDecl(const NamedDecl *D,
 
   // C++ [basic.link]p6:
   //   The name of a function declared in block scope and the name of
   //   an object declared by a block scope extern declaration have
   //   linkage. If there is a visible declaration of an entity with
   //   linkage having the same name and type, ignoring entities
   //   declared outside the innermost enclosing namespace scope, the
   //   block scope declaration declares that same entity and receives
   //   the linkage of the previous declaration. If there is more than
   //   one such matching entity, the program is ill-formed. Otherwise,
   //   if no matching entity is found, the block scope entity receives
   //   external linkage.
   if (D->getDeclContext()->isFunctionOrMethod())
     return getLVForLocalDecl(D, computation);
 
   // C++ [basic.link]p6:
   //   Names not covered by these rules have no linkage.
   return LinkageInfo::none();

clang/test/CodeGenCXX/lambda-expressions-nested-linkage.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -fblocks -emit-llvm -o - %s -fexceptions -std=c++11 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -fblocks -emit-llvm -o - %s -fexceptions -std=c++14 | FileCheck --check-prefixes=CHECK,CXX14 %s
 
 // CHECK-LABEL: define void @_ZN19non_inline_function3fooEv()
 // CHECK-LABEL: define internal void @"_ZZN19non_inline_function3fooEvENK3$_0clEi"(%class.anon
 // CHECK-LABEL: define internal signext i8 @"_ZZZN19non_inline_function3fooEvENK3$_0clEiENKUlcE_clEc"(%class.anon
 namespace non_inline_function {
 void foo() {
   auto L = [](int a) {
     return [](char b) {
auto L = [](int a) {
     return [](char b) {
      return b;
     };
   };
   L(3)('a');
 }
 int use = foo();
 }
+
+#if __cplusplus >= 201402L
+// CXX14-LABEL: define internal void @"_ZZZN32lambda_capture_in_generic_lambda3fooIiEEDavENKUlT_E_clIZNS_L1fEvE3$_1EEDaS1_ENKUlvE_clEv"
+namespace lambda_capture_in_generic_lambda {
+template <typename T> auto foo() {
+  return [](auto func) {
+    [func] { func(); }();
+  };
+}
+static void f() {
+  foo<int>()([] { });
+}
+void f1() { f(); }
+}
+#endif