[clang-tidy] Add check 'modernize-return-braced-init-list'

[JDevlieghere]

Summary

Replaces explicit calls to the constructor in a return with a braced
initializer list. This way the return type is not needlessly duplicated in the
return type and the return statement.

Foo bar() {
  Baz baz;
  return Foo(baz);
}

// transforms to:

Foo bar() {
  Baz baz;
  return {baz};
}

[malcolm.parsons]

What happens if the function has auto as the return type?

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

24

C++11?

38

typo - only.

[JDevlieghere]

• Fixed comments from @malcolm.parsons

In D28768#647177, @malcolm.parsons wrote:

What happens if the function has auto as the return type?

Nothing, the constructor is left untouched.

[malcolm.parsons]

In D28768#647198, @JDevlieghere wrote:

In D28768#647177, @malcolm.parsons wrote:

What happens if the function has auto as the return type?

Nothing, the constructor is left untouched.

Please add a test.

[JDevlieghere]

In D28768#647203, @malcolm.parsons wrote:

In D28768#647198, @JDevlieghere wrote:

In D28768#647177, @malcolm.parsons wrote:

What happens if the function has auto as the return type?

Nothing, the constructor is left untouched.

Please add a test.

I wanted to do that but it seems that the test script hard codes it to C++11, and the auto return type is a C++14 feature. Maybe I'm mistaken though, but I didn't manage to get it working, even when appending -- -std=c++14 to the RUN command. Am I missing something?

[malcolm.parsons]

In D28768#647204, @JDevlieghere wrote:

I wanted to do that but it seems that the test script hard codes it to C++11, and the auto return type is a C++14 feature. Maybe I'm mistaken though, but I didn't manage to get it working, even when appending -- -std=c++14 to the RUN command. Am I missing something?

You need one -- for check_clang_tidy and one for clang-tidy:
-- -- -std=c++14

[JDevlieghere]

In D28768#647206, @malcolm.parsons wrote:

In D28768#647204, @JDevlieghere wrote:

I wanted to do that but it seems that the test script hard codes it to C++11, and the auto return type is a C++14 feature. Maybe I'm mistaken though, but I didn't manage to get it working, even when appending -- -std=c++14 to the RUN command. Am I missing something?

You need one -- for check_clang_tidy and one for clang-tidy:
-- -- -std=c++14

Thanks, I forgot about the extra --! :-)

[JDevlieghere]

Add test for auto return type.

[malcolm.parsons]

{} doesn't allow narrowing; can you check for that?

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

51

Test?

57

Test?

66

Test?

69

What happens for multi-token types like vector<int>?

[Prazek]

Thanks for the check. Have you run it on llvm?

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

28–33

Uppercase

39

Wouldn't
returnStmt(has(ctorAsArgument))

be sufficient?
or maybe

returnStmt(has(ignoringImplici(ctorAsArgument)))

hasDescendant is slow, and besides it probably match for cases like:

return fun(A(a, b, c));

where fun is call, and ctorAsArgument will match to A()

[aaron.ballman]

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

61

This diagnostic doesn't really tell the user what's wrong with the code. Why is a braced init list better than another kind of initialization expression? Perhaps: "to avoid repeating the return type from the declaration, use a braced initializer list instead" or something along those lines?

63

Please do not use auto here, the type is not explicitly spelled out in the initialization.

test/clang-tidy/modernize-return-braced-init-list.cpp

39

We should probably have a test that ensures this code

[]() { return std::vector<int>({1, 2}); }();

does not get converted into this code

[]() { return {1, 2}; }();

[JDevlieghere]

• Added more tests
• Improved matchers
• Addressed code review comments from @malcolm.parsons, @Prazek and @aaron.ballman

[JDevlieghere]

In D28768#647333, @Prazek wrote:

Thanks for the check. Have you run it on llvm?

Not yet, there was an issue with templated types and I wanted to fix that first. It's running now.

[Prazek]

test/clang-tidy/modernize-return-braced-init-list.cpp

96

please also add test that contains
for function
Type foo():

return call(Type());

return OtherType(Type()); // implicit conversion

It would also good to have test that already contain braces :)

return {};

[JDevlieghere]

• Don't replace explicit constructors
• Add @Prazek's suggested tests

As mentioned by @malcolm.parsons, type narrowing is still an issue. I have tried a few thing but I don't know how I can check for this. Does anybody have a suggestion?

[Prazek]

Do you have some results from running it on LLVM? If nothing crashes and all fixit are correct then LGTM.

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

28–33

Is it worth adding new variable to save 2 characters?

test/clang-tidy/modernize-return-braced-init-list.cpp

107

Also add test like:

return Bar{};

(If this construct is valid)

123

also make one like

return f9(Foo());

[JDevlieghere]

In D28768#647949, @Prazek wrote:

Do you have some results from running it on LLVM? If nothing crashes and all fixit are correct then LGTM.

There's still an issue with type narrowing, which is allowed in regular constructor but not in braced initializer lists. I'd like to skip cases where narrowing occurs, either in the matcher or in the check method, but I haven't figured out how yet.

[alexfh]

test/clang-tidy/modernize-return-braced-init-list.cpp

133

Please add tests with the replaced code being inside a template (both for class and function templates) with multiple instantiations. Two interesting variations are when the return expression is type dependent and when it's not.

[malcolm.parsons]

This fixes PR24967.

[JDevlieghere]

• Added test cases suggested by @Prazek
• Added test cases suggested by @alexfh

I don't match on CXXUnresolvedConstructExpr so the template dependent cases are not impacted by this check. This is what I intended, because we cannot make assumptions about the constructor being explicit, narrowing, etc.

[alexfh]

test/clang-tidy/modernize-return-braced-init-list.cpp

151

"With multiple instantiations" is an important part of my comment above. Can you add a couple of instantiations of this function? Same for the function and the class below.

[JDevlieghere]

• Added missing instantiations in test

[aaron.ballman]

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

60

Can't this be handled as part of the matcher? Something like hasDeclaration(cxxConstructorDecl(isExplicit())) should work.

[JDevlieghere]

• Add explicit check to matcher as suggested by @aaron.ballman

[alexfh]

Please mark all addressed comments "Done".

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

61

Please follow LLVM naming conventions (variables should StartWithUpperCase).

73

1. getAsFunction() is not needed, CXXConstructorDecl derives from FunctionDecl
2. A simple loop from 0 to getNumParams() would make it easier to see that the code is correct
3. s/i/I/

94

SourceRange is implicitly constructible from SourceLocation, so you need to supply the same location twice. Same below.

[JDevlieghere]

• Fixed issues raised by @alexfh

[aaron.ballman]

I found a few more small nits, but basically LGTM.

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

71

I should be unsigned rather than int.

81–86

This could be hoisted above the for loop to early return while doing less work.

89

Not keen on this use of auto, as the type is not spelled out in the initialization.

[alexfh]

A couple of comments.

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

36

Nit: I see no point in this variable. I'd merge has into either the matcher above or the one below.

75

I wonder whether MatchedConstructExpr can have fewer arguments than the declaration (e.g. when there are default arguments). Could you add a test with default arguments and check whether this code works correctly?

[JDevlieghere]

Thanks for reviewing @aaron.ballman and @alexfh. I have updated the diff to address your issues. While looking at the logic that checked for matching argument types I discovered that I was looking at the wrong declaration, which has also been fixed.

[alexfh]

A few more nits.

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

67

nit: Use a semicolon before "use": ; use.

docs/clang-tidy/checks/modernize-return-braced-init-list.rst

9

"return type is not ... duplicated in the return type" doesn't read well. "return type is not ... duplicated in the function definition" maybe?

test/clang-tidy/modernize-return-braced-init-list.cpp

72

Please truncate the static repeated parts of the CHECK lines around the 80th column (e.g. after "type" or after "declaration;", if the latter still fits into 80 columns). The first CHECK line should be complete though.

73

This pattern is not reliable, since there are multiple return statements involving b in this file. The only way check patterns are bound to the line is using the content (for this reason CHECK-MESSAGES contains :[[@LINE-x]]:...).

In case of CHECK-FIXES the easiest way to ensure patterns match only what is intended, is to make their content unique. Here I'd give all variables unique names (b1, b2, ..., for example). If there are multiple identical lines that contain no identifiers, they can be made unique by adding comments (and matching them).

[JDevlieghere]

• Updated the diff with comments from @alexfh

Thanks for mentioning the check fixes pattern, it's quite crucial but I never really thought about that!

[alexfh]

LGTM. Please wait for Aaron as well.

[aaron.ballman]

There's one small wording nit with the diagnostic, but once that's resolved, LGTM as well.

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

66

This diagnostic reads strangely. I think you should drop the "to" at the start of the sentence.

[JDevlieghere]

Fixed latest comment from @aaron.ballman before landing.

clang-tidy/modernize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyModernizeModule
   AvoidBindCheck.cpp
   DeprecatedHeadersCheck.cpp
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MakeSmartPtrCheck.cpp
   MakeSharedCheck.cpp
   MakeUniqueCheck.cpp
   ModernizeTidyModule.cpp
   PassByValueCheck.cpp
   RawStringLiteralCheck.cpp
   RedundantVoidArgCheck.cpp
   ReplaceAutoPtrCheck.cpp
+  ReturnBracedInitListCheck.cpp
   ShrinkToFitCheck.cpp
   UseAutoCheck.cpp
   UseBoolLiteralsCheck.cpp
   UseDefaultMemberInitCheck.cpp
   UseEmplaceCheck.cpp
   UseEqualsDefaultCheck.cpp
   UseEqualsDeleteCheck.cpp
   UseNullptrCheck.cpp

clang-tidy/modernize/ModernizeTidyModule.cpp

 #include "DeprecatedHeadersCheck.h"
 #include "LoopConvertCheck.h"
 #include "MakeSharedCheck.h"
 #include "MakeUniqueCheck.h"
 #include "PassByValueCheck.h"
 #include "RawStringLiteralCheck.h"
 #include "RedundantVoidArgCheck.h"
 #include "ReplaceAutoPtrCheck.h"
+#include "ReturnBracedInitListCheck.h"
 #include "ShrinkToFitCheck.h"
 #include "UseAutoCheck.h"
 #include "UseBoolLiteralsCheck.h"
 #include "UseDefaultMemberInitCheck.h"
 #include "UseEmplaceCheck.h"
 #include "UseEqualsDefaultCheck.h"
 #include "UseEqualsDeleteCheck.h"
 #include "UseNullptrCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
     CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
     CheckFactories.registerCheck<RawStringLiteralCheck>(
         "modernize-raw-string-literal");
     CheckFactories.registerCheck<RedundantVoidArgCheck>(
         "modernize-redundant-void-arg");
     CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
         "modernize-replace-auto-ptr");
+    CheckFactories.registerCheck<ReturnBracedInitListCheck>(
+        "modernize-return-braced-init-list");
     CheckFactories.registerCheck<ShrinkToFitCheck>("modernize-shrink-to-fit");
     CheckFactories.registerCheck<UseAutoCheck>("modernize-use-auto");
     CheckFactories.registerCheck<UseBoolLiteralsCheck>(
         "modernize-use-bool-literals");
     CheckFactories.registerCheck<UseDefaultMemberInitCheck>(
         "modernize-use-default-member-init");
     CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace");
     CheckFactories.registerCheck<UseEqualsDefaultCheck>("modernize-use-equals-default");

clang-tidy/modernize/ReturnBracedInitListCheck.h

+//===--- ReturnBracedInitListCheck.h - clang-tidy----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RETURN_BRACED_INIT_LIST_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RETURN_BRACED_INIT_LIST_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// Use a braced init list for return statements rather than unnecessary
+/// repeating the return type name.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-return-braced-init-list.html
+class ReturnBracedInitListCheck : public ClangTidyCheck {
+public:
+  ReturnBracedInitListCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RETURN_BRACED_INIT_LIST_H

clang-tidy/modernize/ReturnBracedInitListCheck.cpp

+//===--- ReturnBracedInitListCheck.cpp - clang-tidy------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReturnBracedInitListCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Tooling/FixIt.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) {
+  // Only register the matchers for C++.
+  if (!getLangOpts().CPlusPlus11)
+    return;
+
+  // Skip list initialization and constructors with an initializer list.
+  auto ConstructExpr =
+      cxxConstructExpr(
+          unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())),
+                       isListInitialization(), hasDescendant(initListExpr()),
+                       isInTemplateInstantiation())))
+          .bind("ctor");
+
+  auto CtorAsArgument = materializeTemporaryExpr(anyOf(
+      has(ConstructExpr), has(cxxFunctionalCastExpr(has(ConstructExpr)))));
+
+  Finder->addMatcher(
+      functionDecl(isDefinition(), // Declarations don't have return statements.
+                   returns(unless(anyOf(builtinType(), autoType()))),
+                   hasDescendant(returnStmt(hasReturnValue(
+                       has(cxxConstructExpr(has(CtorAsArgument)))))))
+          .bind("fn"),
+      this);
+}
+
+void ReturnBracedInitListCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *MatchedFunctionDecl = Result.Nodes.getNodeAs<FunctionDecl>("fn");
+  const auto *MatchedConstructExpr =
+      Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
+
+  // Don't make replacements in macro.
+  SourceLocation Loc = MatchedConstructExpr->getExprLoc();
+  if (Loc.isMacroID())
+    return;
+
+  // Make sure that the return type matches the constructed type.
+  const QualType ReturnType =
+      MatchedFunctionDecl->getReturnType().getCanonicalType();
+  const QualType ConstructType =
+      MatchedConstructExpr->getType().getCanonicalType();
+  if (ReturnType != ConstructType)
+    return;
+
+  auto Diag = diag(Loc, "avoid repeating the return type from the "
+                        "declaration; use a braced initializer list instead");
+
+  const SourceRange CallParensRange =
+      MatchedConstructExpr->getParenOrBraceRange();
+
+  // Make sure there is an explicit constructor call.
+  if (CallParensRange.isInvalid())
+    return;
+
+  // Make sure that the ctor arguments match the declaration.
+  for (unsigned I = 0, NumParams = MatchedConstructExpr->getNumArgs();
+       I < NumParams; ++I) {
+    if (const auto *VD = dyn_cast<VarDecl>(
+            MatchedConstructExpr->getConstructor()->getParamDecl(I))) {
+      if (MatchedConstructExpr->getArg(I)->getType().getCanonicalType() !=
+          VD->getType().getCanonicalType())
+        return;
+    }
+  }
+
+  // Range for constructor name and opening brace.
+  CharSourceRange CtorCallSourceRange = CharSourceRange::getTokenRange(
+      Loc, CallParensRange.getBegin().getLocWithOffset(-1));
+
+  Diag << FixItHint::CreateRemoval(CtorCallSourceRange)
+       << FixItHint::CreateReplacement(CallParensRange.getBegin(), "{")
+       << FixItHint::CreateReplacement(CallParensRange.getEnd(), "}");
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang

docs/ReleaseNotes.rst

- New `readability-misleading-indentation
 
   Finds misleading indentation where braces should be introduced or the code should be reformatted.
 
 - New `safety-no-assembler
   <http://clang.llvm.org/extra/clang-tidy/checks/safety-no-assembler.html>`_ check
 
   Finds uses of inline assembler.
 
+- New `modernize-return-braced-init-list
+    <http://clang.llvm.org/extra/clang-tidy/checks/modernize-return-braced-init-list.html>`_ check
+
+  Finds and replaces explicit calls to the constructor in a return statement by
+  a braced initializer list so that the return type is not needlessly repeated.
+
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

docs/clang-tidy/checks/list.rst

.. toctree::
    modernize-deprecated-headers
    modernize-loop-convert
    modernize-make-shared
    modernize-make-unique
    modernize-pass-by-value
    modernize-raw-string-literal
    modernize-redundant-void-arg
    modernize-replace-auto-ptr
+   modernize-return-braced-init-list
    modernize-shrink-to-fit
    modernize-use-auto
    modernize-use-bool-literals
    modernize-use-default-member-init
    modernize-use-emplace
    modernize-use-equals-default
    modernize-use-equals-delete
    modernize-use-nullptr

docs/clang-tidy/checks/modernize-return-braced-init-list.rst

+.. title:: clang-tidy - modernize-return-braced-init-list
+
+modernize-return-braced-init-list
+=================================
+
+Replaces explicit calls to the constructor in a return with a braced
+initializer list. This way the return type is not needlessly duplicated in the
+function definition and the return statement.
+
+.. code:: c++
+
+  Foo bar() {
+    Baz baz;
+    return Foo(baz);
+  }
+
+  // transforms to:
+
+  Foo bar() {
+    Baz baz;
+    return {baz};
+  }

test/clang-tidy/modernize-return-braced-init-list.cpp

+// RUN: %check_clang_tidy %s modernize-return-braced-init-list %t -- --
+// -std=c++14
+
+namespace std {
+typedef decltype(sizeof(int)) size_t;
+
+// libc++'s implementation
+template <class _E>
+class initializer_list {
+  const _E *__begin_;
+  size_t __size_;
+
+  initializer_list(const _E *__b, size_t __s)
+      : __begin_(__b),
+        __size_(__s) {}
+
+public:
+  typedef _E value_type;
+  typedef const _E &reference;
+  typedef const _E &const_reference;
+  typedef size_t size_type;
+
+  typedef const _E *iterator;
+  typedef const _E *const_iterator;
+
+  initializer_list() : __begin_(nullptr), __size_(0) {}
+
+  size_t size() const { return __size_; }
+  const _E *begin() const { return __begin_; }
+  const _E *end() const { return __begin_ + __size_; }
+};
+
+template <typename T>
+class vector {
+public:
+  vector(T) {}
+  vector(std::initializer_list<T>) {}
+};
+}
+
+class Bar {};
+
+Bar b0;
+
+class Foo {
+public:
+  Foo(Bar) {}
+  explicit Foo(Bar, unsigned int) {}
+  Foo(unsigned int) {}
+};
+
+class Baz {
+public:
+  Foo m() {
+    Bar bm;
+    return Foo(bm);
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list]
+    // CHECK-FIXES: return {bm};
+  }
+};
+
+class Quux : public Foo {
+public:
+  Quux(Bar bar) : Foo(bar) {}
+  Quux(unsigned, unsigned, unsigned k = 0) : Foo(k) {}
+};
+
+Foo f() {
+  Bar b1;
+  return Foo(b1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {b1};
+}
+
+Foo f2() {
+  Bar b2;
+  return {b2};
+}
+
+auto f3() {
+  Bar b3;
+  return Foo(b3);
+}
+
+#define A(b) Foo(b)
+
+Foo f4() {
+  Bar b4;
+  return A(b4);
+}
+
+Foo f5() {
+  Bar b5;
+  return Quux(b5);
+}
+
+Foo f6() {
+  Bar b6;
+  return Foo(b6, 1);
+}
+
+std::vector<int> f7() {
+  int i7 = 1;
+  return std::vector<int>(i7);
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+}
+
+Bar f8() {
+  return {};
+}
+
+Bar f9() {
+  return Bar();
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+}
+
+Bar f10() {
+  return Bar{};
+}
+
+Foo f11(Bar b11) {
+  return Foo(b11);
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {b11};
+}
+
+Foo f12() {
+  return f11(Bar());
+}
+
+Foo f13() {
+  return Foo(Bar()); // 13
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {Bar()}; // 13
+}
+
+Foo f14() {
+  // FIXME: Type narrowing should not occur!
+  return Foo(-1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {-1};
+}
+
+Foo f15() {
+  return Foo(f10());
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {f10()};
+}
+
+Quux f16() {
+  return Quux(1, 2);
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {1, 2};
+}
+
+Quux f17() {
+  return Quux(1, 2, 3);
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
+  // CHECK-FIXES: return {1, 2, 3};
+}
+
+template <typename T>
+T f19() {
+  return T();
+}
+
+Bar i1 = f19<Bar>();
+Baz i2 = f19<Baz>();
+
+template <typename T>
+Foo f20(T t) {
+  return Foo(t);
+}
+
+Foo i3 = f20(b0);
+
+template <typename T>
+class BazT {
+public:
+  T m() {
+    Bar b;
+    return T(b);
+  }
+
+  Foo m2(T t) {
+    return Foo(t);
+  }
+};
+
+BazT<Foo> bazFoo;
+Foo i4 = bazFoo.m();
+Foo i5 = bazFoo.m2(b0);
+
+BazT<Quux> bazQuux;
+Foo i6 = bazQuux.m();
+Foo i7 = bazQuux.m2(b0);
+
+auto v1 = []() { return std::vector<int>({1, 2}); }();
+auto v2 = []() -> std::vector<int> { return std::vector<int>({1, 2}); }();