Match code following lambdas when ignoring invisible nodes

[aaron.ballman]

LGTM assuming the behavioral change did not break anything in clang-tools-extra.

clang/lib/ASTMatchers/ASTMatchFinder.cpp

bool TraverseLambdaExpr(LambdaExpr *Node) {
     for (const auto *P : Node->getCallOperator()->parameters()) {
       if (!match(*P))
         return false;
     }
 
     if (!match(*Node->getBody()))
       return false;
 
-    return false;
+    return true;
   }
 
   bool shouldVisitTemplateInstantiations() const { return true; }
   bool shouldVisitImplicitCode() const { return true; }
 
 private:
   // Used for updating the depth during traversal.
   struct ScopedIncrement {

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

void func13() {
   int a = 0;
   int c = 0;
 
   [a, b = c](int d) { int e = d; };
 }
 
 void func14() {
   [] <typename TemplateType> (TemplateType t, TemplateType u) { int e = t + u; };
+  float i = 42.0;
 }
 
 )cpp";
 
   EXPECT_TRUE(matches(
       Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func1"))),
                                 hasReturnValue(integerLiteral(equals(42)))))));
EXPECT_TRUE(matches(
                                                    varDecl(hasName("c"))))))),
                      has(parmVarDecl(hasName("d")))))));
 
   EXPECT_TRUE(matches(
       Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
                      lambdaExpr(
                          forFunction(functionDecl(hasName("func14"))),
                          has(templateTypeParmDecl(hasName("TemplateType")))))));
+
+  EXPECT_TRUE(
+      matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                             functionDecl(hasName("func14"),
+                                          hasDescendant(floatLiteral())))));
 }
 
 TEST(IgnoringImpCasts, MatchesImpCasts) {
   // This test checks that ignoringImpCasts matches when implicit casts are
   // present and its inner matcher alone does not match.
   // Note that this test creates an implicit const cast.
   EXPECT_TRUE(matches("int x = 0; const int y = x;",
                       varDecl(hasInitializer(ignoringImpCasts(