bernhardmgruber updated this revision to Diff 182385.
bernhardmgruber marked 19 inline comments as done.
bernhardmgruber added a comment.
Addressed most of the new review comments (mainly uppercasing start of
comments).
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D56160/new/
https://reviews.llvm.org/D56160
Files:
clang-tidy/modernize/CMakeLists.txt
clang-tidy/modernize/ModernizeTidyModule.cpp
clang-tidy/modernize/UseTrailingReturnCheck.cpp
clang-tidy/modernize/UseTrailingReturnCheck.h
docs/ReleaseNotes.rst
docs/clang-tidy/checks/list.rst
docs/clang-tidy/checks/modernize-use-trailing-return.rst
test/clang-tidy/modernize-use-trailing-return.cpp
Index: test/clang-tidy/modernize-use-trailing-return.cpp
===================================================================
--- /dev/null
+++ test/clang-tidy/modernize-use-trailing-return.cpp
@@ -0,0 +1,283 @@
+// RUN: %check_clang_tidy %s modernize-use-trailing-return %t -- -- --std=c++14 -fdeclspec
+
+namespace std {
+ template <typename T>
+ class vector;
+
+ class string;
+}
+
+//
+// Functions
+//
+
+int f();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto f() -> int;{{$}}
+int f(int);
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto f(int) -> int;{{$}}
+int f(int arg);
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto f(int arg) -> int;{{$}}
+int f(int arg1, int arg2, int arg3);
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto f(int arg1, int arg2, int arg3) -> int;{{$}}
+int f(int arg1, int arg2, int arg3, ...);
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto f(int arg1, int arg2, int arg3, ...) -> int;{{$}}
+template <typename T> int f(T t);
+// CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}template <typename T> auto f(T t) -> int;{{$}}
+
+//
+// Functions with formatting
+//
+
+int a1() { return 42; }
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto a1() -> int { return 42; }{{$}}
+int a2() {
+ return 42;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto a2() -> int {{{$}}
+int a3()
+{
+ return 42;
+}
+// CHECK-MESSAGES: :[[@LINE-4]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto a3() -> int{{$}}
+int a4(int arg ) ;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto a4(int arg ) -> int ;{{$}}
+int a5
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto a5{{$}}
+(int arg);
+// CHECK-FIXES: {{^}}(int arg) -> int;{{$}}
+
+//
+// Functions with qualifiers and specifiers
+//
+
+inline int d1(int arg);
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}inline auto d1(int arg) -> int;{{$}}
+extern "C" int d2(int arg);
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}extern "C" auto d2(int arg) -> int;{{$}}
+inline int d3(int arg) noexcept(true);
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}inline auto d3(int arg) -> int noexcept(true);{{$}}
+inline int d4(int arg) try { } catch(...) { }
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}inline auto d4(int arg) -> int try { } catch(...) { }{{$}}
+
+//
+// Functions in namespaces
+//
+
+namespace N {
+ int e1();
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:9: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto e1() -> int;{{$}}
+int N::e1() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto N::e1() -> int {}{{$}}
+
+//
+// Functions with complex return types
+//
+
+inline volatile const std::vector<std::string> e2();
+// CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}inline auto e2() -> volatile const std::vector<std::string>;{{$}}
+inline const std::vector<std::string> volatile e2();
+// CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}inline auto e2() -> const std::vector<std::string> volatile;{{$}}
+inline std::vector<std::string> const volatile e2();
+// CHECK-MESSAGES: :[[@LINE-1]]:48: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}inline auto e2() -> std::vector<std::string> const volatile;{{$}}
+int (*e3())(double);
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use a trailing return type for this function [modernize-use-trailing-return]
+struct A;
+int A::* e5();
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return]
+int std::vector<std::string>::* e6();
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use a trailing return type for this function [modernize-use-trailing-return]
+int (std::vector<std::string>::*e7())(double);
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use a trailing return type for this function [modernize-use-trailing-return]
+int* e8();
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto e8() -> int*;{{$}}
+
+// TODO: not matched by the AST matcher
+//decltype(auto) e6();
+// _HECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// _HECK-FIXES: {{^}}auto e6() -> decltype(auto);{{$}}
+
+//
+// Methods
+//
+
+struct B {
+ B& operator=(const B&);
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto operator=(const B&) -> B&;{{$}}
+
+ double base1(int, bool b);
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto base1(int, bool b) -> double;{{$}}
+
+ virtual double base2(int, bool b) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} virtual auto base2(int, bool b) -> double {}{{$}}
+
+ virtual float base3() const = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} virtual auto base3() const -> float = 0;{{$}}
+
+ virtual float base4() volatile = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} virtual auto base4() volatile -> float = 0;{{$}}
+
+ double base5(int, bool b) &&;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto base5(int, bool b) && -> double;{{$}}
+
+ double base6(int, bool b) const &&;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto base6(int, bool b) const && -> double;{{$}}
+
+ double base7(int, bool b) const & = delete;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto base7(int, bool b) const & -> double = delete;{{$}}
+
+ double base8(int, bool b) const volatile & = delete;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} auto base8(int, bool b) const volatile & -> double = delete;{{$}}
+};
+
+double B::base1(int, bool b) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto B::base1(int, bool b) -> double {}{{$}}
+
+struct D : B {
+ virtual double f1(int, bool b) final;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} virtual auto f1(int, bool b) -> double final;{{$}}
+
+ virtual double base2(int, bool b) override;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} virtual auto base2(int, bool b) -> double override;{{$}}
+
+ virtual float base3() const override final { }
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}} virtual auto base3() const -> float override final { }{{$}}
+};
+
+//
+// Functions with attributes
+//
+
+int g1() [[asdf]];
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto g1() -> int {{[[][[]}}asdf{{[]][]]}};{{$}}
+[[noreturn]] int g2();
+// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}{{[[][[]}}noreturn{{[]][]]}} auto g2() -> int;{{$}}
+int g2 [[noreturn]] ();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto g2 {{[[][[]}}noreturn{{[]][]]}} () -> int;{{$}}
+
+//
+// Templates
+//
+template <typename Container>
+[[maybe_unused]] typename Container::value_type const volatile&& t1(Container& C) noexcept;
+// CHECK-MESSAGES: :[[@LINE-1]]:66: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}{{[[][[]}}maybe_unused{{[]][]]}} auto t1(Container& C) -> typename Container::value_type const volatile&& noexcept;{{$}}
+
+//
+// Macros
+//
+
+#define DWORD unsigned int
+DWORD h1();
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto h1() -> DWORD;{{$}}
+#define INT int
+#define UNSIGNED unsigned
+UNSIGNED INT h2();
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto h2() -> UNSIGNED INT;{{$}}
+#define CONST const
+CONST int h3();
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: use a trailing return type for this function [modernize-use-trailing-return]
+#define ALWAYS_INLINE inline
+#define DLL_EXPORT __declspec(dllexport)
+ALWAYS_INLINE DLL_EXPORT int h4();
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}ALWAYS_INLINE DLL_EXPORT auto h4() -> int;{{$}}
+#define ANOTHER_ATTRIBUTE __attribute__((deprecated))
+int h5() ANOTHER_ATTRIBUTE;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto h5() -> int ANOTHER_ATTRIBUTE;{{$}}
+#define FUNCTION_NAME(a, b) a##b
+int FUNCTION_NAME(foo, bar)();
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto FUNCTION_NAME(foo, bar)() -> int;{{$}}
+#define DEFINE_FUNCTION_1(a, b) int a##b()
+DEFINE_FUNCTION_1(foo, bar);
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use a trailing return type for this function [modernize-use-trailing-return]
+#define DEFINE_FUNCTION_2 int foo(int arg);
+DEFINE_FUNCTION_2
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use a trailing return type for this function [modernize-use-trailing-return]
+#define DLL_EXPORT_CONST __declspec(dllexport) const
+DLL_EXPORT_CONST int h6();
+// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: use a trailing return type for this function [modernize-use-trailing-return]
+
+template <typename T>
+using Real = T;
+#define PRECISION float
+Real<PRECISION> h7() { return 0.; }
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}auto h7() -> Real<PRECISION> { return 0.; }{{$}}
+
+#define MAYBE_UNUSED_MACRO [[maybe_unused]]
+template <typename Container>
+MAYBE_UNUSED_MACRO typename Container::value_type const volatile** const myFunnyFunction(Container& C) noexcept;
+// CHECK-MESSAGES: :[[@LINE-1]]:74: warning: use a trailing return type for this function [modernize-use-trailing-return]
+// CHECK-FIXES: {{^}}MAYBE_UNUSED_MACRO auto myFunnyFunction(Container& C) -> typename Container::value_type const volatile** const noexcept;{{$}}
+
+//
+// Samples which do not trigger the check
+//
+
+auto ff();
+auto f() -> int;
+auto f(int) -> int;
+auto f(int arg) -> int;
+auto f(int arg1, int arg2, int arg3) -> int;
+auto f(int arg1, int arg2, int arg3, ...) -> int;
+template <typename T> auto f(T t) -> int;
+
+void c();
+void c(int arg);
+void c(int arg) { return; }
+
+struct D2 : B {
+ D2();
+ virtual ~D2();
+
+ virtual auto f1(int, bool b) -> double final;
+ virtual auto base2(int, bool b) -> double override;
+ virtual auto base3() const -> float override final { }
+
+ operator double();
+};
+
+auto l1 = [](int arg) {};
+auto l2 = [](int arg) -> double {};
Index: docs/clang-tidy/checks/modernize-use-trailing-return.rst
===================================================================
--- /dev/null
+++ docs/clang-tidy/checks/modernize-use-trailing-return.rst
@@ -0,0 +1,34 @@
+.. title:: clang-tidy - modernize-use-trailing-return
+
+modernize-use-trailing-return
+=============================
+
+Rewrites function signatures to use a trailing return type
+(introduced in C++11). This transformation is purely stylistic.
+The return type before the function name is replaced by ``auto``
+and inserted after the function parameter list (and qualifiers).
+
+Example
+-------
+
+.. code-block:: c++
+
+ int f1();
+ inline int f2(int arg) noexcept;
+ virtual float f3() const && = delete;
+
+transforms to:
+
+.. code-block:: c++
+
+ auto f1() -> int;
+ inline auto f2(int arg) -> int noexcept;
+ virtual auto f3() const && -> float = delete;
+
+Known Limitations
+-----------------
+
+The following categories of return types cannot be rewritten currently:
+* function pointers
+* member function pointers
+* member pointers
Index: docs/clang-tidy/checks/list.rst
===================================================================
--- docs/clang-tidy/checks/list.rst
+++ docs/clang-tidy/checks/list.rst
@@ -211,6 +211,7 @@
modernize-use-noexcept
modernize-use-nullptr
modernize-use-override
+ modernize-use-trailing-return
modernize-use-transparent-functors
modernize-use-uncaught-exceptions
modernize-use-using
Index: docs/ReleaseNotes.rst
===================================================================
--- docs/ReleaseNotes.rst
+++ docs/ReleaseNotes.rst
@@ -67,7 +67,10 @@
Improvements to clang-tidy
--------------------------
-- ...
+- New :doc:`modernize-use-trailing-return
+ <clang-tidy/checks/modernize-use-trailing-return>` check.
+
+ Rewrites function signatures to use a trailing return type.
Improvements to include-fixer
-----------------------------
Index: clang-tidy/modernize/UseTrailingReturnCheck.h
===================================================================
--- /dev/null
+++ clang-tidy/modernize/UseTrailingReturnCheck.h
@@ -0,0 +1,48 @@
+//===--- UseTrailingReturnCheck.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_USETRAILINGRETURNCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// Rewrites function signatures to use a trailing return type.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-trailing-return.html
+class UseTrailingReturnCheck : public ClangTidyCheck {
+public:
+ UseTrailingReturnCheck(StringRef Name, ClangTidyContext *Context)
+ : ClangTidyCheck(Name, Context) {}
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+ void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+ SourceLocation findTrailingReturnTypeSourceLocation(
+ const FunctionDecl &F, const ASTContext &Ctx, const SourceManager &SM,
+ const LangOptions &LangOpts);
+ llvm::Optional<SmallVector<Token, 8>>
+ nonMacroTokensBeforeFunctionName(const FunctionDecl &F, const ASTContext &Ctx,
+ const SourceManager &SM,
+ const LangOptions &LangOpts);
+ SourceRange findReturnTypeAndCVSourceRange(const FunctionDecl &F,
+ const ASTContext &Ctx,
+ const SourceManager &SM,
+ const LangOptions &LangOpts);
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNCHECK_H
Index: clang-tidy/modernize/UseTrailingReturnCheck.cpp
===================================================================
--- /dev/null
+++ clang-tidy/modernize/UseTrailingReturnCheck.cpp
@@ -0,0 +1,222 @@
+//===--- UseTrailingReturnCheck.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 "UseTrailingReturnCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/FixIt.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+constexpr llvm::StringLiteral Message =
+ "use a trailing return type for this function";
+
+static SourceLocation expandIfMacroId(SourceLocation Loc,
+ const SourceManager &SM) {
+ if (Loc.isMacroID())
+ Loc = SM.getImmediateExpansionRange(Loc).getBegin();
+ return Loc;
+}
+
+SourceLocation UseTrailingReturnCheck::findTrailingReturnTypeSourceLocation(
+ const FunctionDecl &F, const ASTContext &Ctx, const SourceManager &SM,
+ const LangOptions &LangOpts) {
+ // We start with the location of the closing parenthesis.
+ const TypeSourceInfo *TSI = F.getTypeSourceInfo();
+ if (!TSI) {
+ diag(F.getLocation(), Message);
+ return {};
+ }
+ FunctionTypeLoc FTL =
+ TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>();
+ if (!FTL) {
+ diag(F.getLocation(), Message);
+ return {};
+ }
+
+ // If the function argument list ends inside of a macro, it is dangerous to
+ // start lexing from here - bail out.
+ SourceLocation ClosingParen = FTL.getRParenLoc();
+ if (ClosingParen.isMacroID()) {
+ diag(F.getLocation(), Message);
+ return {};
+ }
+
+ SourceLocation Result =
+ Lexer::getLocForEndOfToken(ClosingParen, 0, SM, LangOpts);
+
+ // Skip subsequent CV and ref qualifiers.
+ std::pair<FileID, unsigned> Loc = SM.getDecomposedLoc(Result);
+ StringRef File = SM.getBufferData(Loc.first);
+ const char *TokenBegin = File.data() + Loc.second;
+ Lexer Lexer(SM.getLocForStartOfFile(Loc.first), LangOpts, File.begin(),
+ TokenBegin, File.end());
+ Token T;
+ while (!Lexer.LexFromRawLexer(T)) {
+ if (T.is(tok::raw_identifier)) {
+ IdentifierInfo &Info = Ctx.Idents.get(
+ StringRef(SM.getCharacterData(T.getLocation()), T.getLength()));
+ T.setIdentifierInfo(&Info);
+ T.setKind(Info.getTokenID());
+ }
+
+ if (T.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile)) {
+ Result = T.getEndLoc();
+ continue;
+ }
+
+ break;
+ }
+
+ return Result;
+}
+
+llvm::Optional<SmallVector<Token, 8>>
+UseTrailingReturnCheck::nonMacroTokensBeforeFunctionName(
+ const FunctionDecl &F, const ASTContext &Ctx, const SourceManager &SM,
+ const LangOptions &LangOpts) {
+ SourceLocation BeginF = expandIfMacroId(F.getBeginLoc(), SM);
+ SourceLocation BeginNameF = expandIfMacroId(F.getLocation(), SM);
+
+ // Create tokens for everything before the name of the function.
+ std::pair<FileID, unsigned> Loc = SM.getDecomposedLoc(BeginF);
+ StringRef File = SM.getBufferData(Loc.first);
+ const char *TokenBegin = File.data() + Loc.second;
+ Lexer Lexer(SM.getLocForStartOfFile(Loc.first), LangOpts, File.begin(),
+ TokenBegin, File.end());
+ Token T;
+ SmallVector<Token, 8> Tokens;
+ while (!Lexer.LexFromRawLexer(T)) {
+ if (SM.isBeforeInTranslationUnit(BeginNameF, T.getLocation()))
+ break;
+ if (T.is(tok::raw_identifier)) {
+ IdentifierInfo &Info = Ctx.Idents.get(
+ StringRef(SM.getCharacterData(T.getLocation()), T.getLength()));
+ if (Info.hasMacroDefinition()) {
+ // The CV qualifiers of the return type are inside macros
+ diag(F.getLocation(), Message);
+ return {};
+ }
+ T.setIdentifierInfo(&Info);
+ T.setKind(Info.getTokenID());
+ }
+ Tokens.push_back(T);
+ }
+ return Tokens;
+}
+
+SourceRange UseTrailingReturnCheck::findReturnTypeAndCVSourceRange(
+ const FunctionDecl &F, const ASTContext &Ctx, const SourceManager &SM,
+ const LangOptions &LangOpts) {
+
+ // We start with the range of the return type and expand to neighboring
+ // 'const' and 'volatile'.
+ SourceRange ReturnTypeRange = F.getReturnTypeSourceRange();
+ if (ReturnTypeRange.isInvalid()) {
+ // Happens if e.g. clang cannot resolve all includes and the return type is
+ // unknown.
+ diag(F.getLocation(), Message);
+ return {};
+ }
+
+ // If the return type has no local qualifiers, it's source range is accurate.
+ if (!F.getReturnType().hasLocalQualifiers())
+ return ReturnTypeRange;
+
+ // Include const and volatile to the left and right of the return type.
+ llvm::Optional<SmallVector<Token, 8>> MaybeTokens =
+ nonMacroTokensBeforeFunctionName(F, Ctx, SM, LangOpts);
+ if (!MaybeTokens)
+ return {};
+ const SmallVector<Token, 8> &Tokens = *MaybeTokens;
+
+ auto IsCV = [](Token T) {
+ return T.isOneOf(tok::kw_const, tok::kw_volatile);
+ };
+
+ bool ExtendedLeft = false;
+ for (size_t I = 0; I < Tokens.size(); I++) {
+ // If we found the beginning of the return type, include const and volatile
+ // to the left.
+ if (!SM.isBeforeInTranslationUnit(Tokens[I].getLocation(),
+ ReturnTypeRange.getBegin()) &&
+ !ExtendedLeft) {
+ for (int J = static_cast<int>(I) - 1; J >= 0 && IsCV(Tokens[J]); J--)
+ ReturnTypeRange.setBegin(Tokens[J].getLocation());
+ ExtendedLeft = true;
+ }
+ // If we found the end of the return type, include const and volatile to the
+ // right.
+ if (SM.isBeforeInTranslationUnit(ReturnTypeRange.getEnd(),
+ Tokens[I].getLocation())) {
+ for (size_t J = I; J < Tokens.size() && IsCV(Tokens[J]); J++)
+ ReturnTypeRange.setEnd(Tokens[J].getLocation());
+ break;
+ }
+ }
+
+ return ReturnTypeRange;
+}
+
+void UseTrailingReturnCheck::registerMatchers(MatchFinder *Finder) {
+ if (!getLangOpts().CPlusPlus11)
+ return;
+
+ Finder->addMatcher(
+ functionDecl(unless(anyOf(hasTrailingReturn(), returns(voidType()),
+ returns(autoType()), cxxConversionDecl(),
+ cxxMethodDecl(isImplicit()))))
+ .bind("f"),
+ this);
+}
+
+void UseTrailingReturnCheck::check(const MatchFinder::MatchResult &Result) {
+ const auto *F = Result.Nodes.getNodeAs<FunctionDecl>("f");
+ assert(F && "Matcher is expected to find only FunctionDecls");
+
+ if (F->getLocation().isInvalid())
+ return;
+
+ // TODO: implement those
+ if (F->getDeclaredReturnType()->isFunctionPointerType() ||
+ F->getDeclaredReturnType()->isMemberFunctionPointerType() ||
+ F->getDeclaredReturnType()->isMemberPointerType()) {
+ diag(F->getLocation(), Message);
+ return;
+ }
+
+ const ASTContext &Ctx = *Result.Context;
+ const SourceManager &SM = *Result.SourceManager;
+ const LangOptions &LangOpts = getLangOpts();
+
+ SourceLocation InsertionLoc =
+ findTrailingReturnTypeSourceLocation(*F, Ctx, SM, LangOpts);
+ if (InsertionLoc.isInvalid())
+ return;
+
+ // Using the declared return type via F->getDeclaredReturnType().getAsString()
+ // discards user formatting and order of const, volatile, type, whitespace,
+ // space before & ... .
+ SourceRange ReturnTypeCVRange =
+ findReturnTypeAndCVSourceRange(*F, Ctx, SM, LangOpts);
+ if (ReturnTypeCVRange.isInvalid())
+ return;
+ StringRef ReturnType = tooling::fixit::getText(ReturnTypeCVRange, Ctx);
+
+ diag(F->getLocation(), Message)
+ << FixItHint::CreateReplacement(ReturnTypeCVRange, "auto")
+ << FixItHint::CreateInsertion(InsertionLoc, (" -> " + ReturnType).str());
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
Index: clang-tidy/modernize/ModernizeTidyModule.cpp
===================================================================
--- clang-tidy/modernize/ModernizeTidyModule.cpp
+++ clang-tidy/modernize/ModernizeTidyModule.cpp
@@ -36,6 +36,7 @@
#include "UseNoexceptCheck.h"
#include "UseNullptrCheck.h"
#include "UseOverrideCheck.h"
+#include "UseTrailingReturnCheck.h"
#include "UseTransparentFunctorsCheck.h"
#include "UseUncaughtExceptionsCheck.h"
#include "UseUsingCheck.h"
@@ -88,6 +89,8 @@
CheckFactories.registerCheck<UseNoexceptCheck>("modernize-use-noexcept");
CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr");
CheckFactories.registerCheck<UseOverrideCheck>("modernize-use-override");
+ CheckFactories.registerCheck<UseTrailingReturnCheck>(
+ "modernize-use-trailing-return");
CheckFactories.registerCheck<UseTransparentFunctorsCheck>(
"modernize-use-transparent-functors");
CheckFactories.registerCheck<UseUncaughtExceptionsCheck>(
Index: clang-tidy/modernize/CMakeLists.txt
===================================================================
--- clang-tidy/modernize/CMakeLists.txt
+++ clang-tidy/modernize/CMakeLists.txt
@@ -30,6 +30,7 @@
UseNoexceptCheck.cpp
UseNullptrCheck.cpp
UseOverrideCheck.cpp
+ UseTrailingReturnCheck.cpp
UseTransparentFunctorsCheck.cpp
UseUncaughtExceptionsCheck.cpp
UseUsingCheck.cpp
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
