Classes inside lambdas are local not nested.

[sepavloff]

Summary

If a lambda used as default argument in a method declaration contained
a local class, that class was incorrectly recognized as nested class.
In this case compiler tried to postpone parsing of this class until
the enclosing class is finished, which caused crashes in some cases.

This change fixes PR13987.

[majnemer]

Would this fix PR23860?

[sepavloff]

Yes, it fixes PR23860 also.

Thanks,
--Serge

[rsmith]

lib/Parse/ParseDeclCXX.cpp

2822–2829 ↗

(On Diff #29194)

Do we need to check the parent scope here at all? (Why can't we just break immediately once we reach a function scope?)

[sepavloff]

lib/Parse/ParseDeclCXX.cpp

2822–2829 ↗

(On Diff #29194)

I cannot invent a case where this check would require inspection of parent. Will remove it.

[sepavloff]

Simplified check, organized tests.

[sepavloff]

Ping.

Thanks,
--Serge

[rsmith]

Thanks, LGTM

cfe/trunk/lib/Parse/ParseDeclCXX.cpp

for (const Scope *S = getCurScope(); S; S = S->getParent()) {
             << /*ErrorType=*/6
             << (isa<NamedDecl>(TagDecl)
                   ? cast<NamedDecl>(TagDecl)->getQualifiedNameAsString()
                   : "(anonymous)");
         }
         break;
       }
 
-      if ((S->getFlags() & Scope::FnScope)) {
-        // If we're in a function or function template declared in the
-        // body of a class, then this is a local class rather than a
-        // nested class.
-        const Scope *Parent = S->getParent();
-        if (Parent->isTemplateParamScope())
-          Parent = Parent->getParent();
-        if (Parent->isClassScope())
-          break;
-      }
-    }
-  }
+      if ((S->getFlags() & Scope::FnScope))
+        // If we're in a function or function template then this is a local
+        // class rather than a nested class.
 
   // Enter a scope for the class.
   ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope);
 
   // Note that we are parsing a new (potentially-nested) class definition.
   ParsingClassDefinition ParsingDef(*this, TagDecl, NonNestedClass,
                                     TagType == DeclSpec::TST_interface);
 

cfe/trunk/test/SemaCXX/cxx1y-generic-lambdas.cpp

auto g = [](auto&&... args) {
     };
     return h;
   };
   return g;
 }
 
 auto x = f(0)();
 }
+
+namespace PR13987 {
+class Enclosing {
+  void Method(char c = []()->char {
+    int d = [](auto x)->int {
+        struct LocalClass {
+          int Method() { return 0; }
+        };
+      return 0;
+    }(0);
+    return d; }()
+  );
+};
+
+class Enclosing2 {
+  void Method(char c = [](auto x)->char {
+    int d = []()->int {
+        struct LocalClass {
+          int Method() { return 0; }
+        };
+      return 0;
+    }();
+    return d; }(0)
+  );
+};
+
+class Enclosing3 {
+  void Method(char c = [](auto x)->char {
+    int d = [](auto y)->int {
+        struct LocalClass {
+          int Method() { return 0; }
+        };
+      return 0;
+    }(0);
+    return d; }(0)
+  );
+};
+}

cfe/trunk/test/SemaCXX/lambda-expressions.cpp

 namespace PR21857 {
   template<typename Fn> struct fun : Fn {
     fun() = default;
     using Fn::operator();
   };
   template<typename Fn> fun<Fn> wrap(Fn fn);
   auto x = wrap([](){});
 }
+
+namespace PR13987 {
+class Enclosing {
+  void Method(char c = []()->char {
+    int d = []()->int {
+        struct LocalClass {
+          int Method() { return 0; }
+        };
+      return 0;
+    }();
+    return d; }()
+  );
+};
+}
+
+namespace PR23860 {
+template <class> struct A {
+  void f(int x = []() {
+    struct B {
+      void g() {}
+    };
+    return 0;
+  }());
+};
+
+int main() {
+}
+
+A<int> a;
+}