This is an archive of the discontinued LLVM Phabricator instance.

[clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
ClosedPublic

Authored by alexfh on Oct 25 2014, 7:18 PM.

Download Raw Diff

Details

Reviewers

Commits

rG106c8e089868: [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
rCTE220634: [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
rL220634: [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh

Summary

Make the script suitable for checking just messages. Move most of the tests to use it. Clean up the tests: shorten messages, insert line numbers, remove unnecessary RUN: lines, etc.

Diff Detail

Event Timeline

alexfh updated this revision to Diff 15453.Oct 25 2014, 7:18 PM

alexfh retitled this revision from to [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh.

alexfh updated this object.

alexfh edited the test plan for this revision. (Show Details)

alexfh added a reviewer: klimek.

alexfh added a subscriber: Unknown Object (MLST).

Herald added a subscriber: curdeius. · View Herald TranscriptOct 25 2014, 7:18 PM

alexfh updated this object.Oct 25 2014, 7:21 PM

Committed obvious unrelated changes separately.

This revision is now accepted and ready to land.Oct 25 2014, 7:58 PM

alexfh closed this revision.Oct 25 2014, 8:08 PM

Revision Contents

Path

Size

test/

clang-tidy/

arg-comments.cpp

13 lines

	check_clang_tidy.sh
	check_clang_tidy_fix.sh

29 lines

check_clang_tidy_fix.sh

google-explicit-make-pair.cpp

2 lines

google-member-string-references.cpp

9 lines

google-memset-zero-length.cpp

2 lines

google-overloaded-unary-and.cpp

14 lines

google-readability-casting.c

2 lines

google-readability-casting.cpp

2 lines

google-readability-function.cpp

2 lines

google-readability-namespace-comments.cpp

2 lines

google-readability-todo.cpp

2 lines

google-runtime-int.cpp

39 lines

llvm-include-order.cpp

2 lines

llvm-twine-local.cpp

2 lines

misc-bool-pointer-implicit-conversion.cpp

2 lines

misc-swapped-arguments.cpp

2 lines

misc-undelegated-constructor.cpp

19 lines

misc-unused-raii.cpp

2 lines

misc-use-override.cpp

2 lines

readability-braces-around-statements-few-lines.cpp

2 lines

readability-braces-around-statements-same-line.cpp

2 lines

readability-braces-around-statements-single-line.cpp

2 lines

readability-braces-around-statements.cpp

2 lines

readability-function-size.cpp

55 lines

readability-redundant-smartptr-get.cpp

2 lines

Diff 15454

test/clang-tidy/arg-comments.cpp

	// RUN: clang-tidy --checks='-*,misc-argument-comment' %s -- -std=c++11 \| FileCheck %s -implicit-check-not='{{warning:\|error:}}'			// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-argument-comment %t
				// REQUIRES: shell

	// FIXME: clang-tidy should provide a -verify mode to make writing these checks			// FIXME: clang-tidy should provide a -verify mode to make writing these checks
	// easier and more accurate.			// easier and more accurate.

	void ffff(int xxxx, int yyyy);			void ffff(int xxxx, int yyyy);

	void f(int x, int y);			void f(int x, int y);
	void g() {			void g() {
	// CHECK: [[@LINE+4]]:5: warning: argument name 'y' in comment does not match parameter name 'x'			// CHECK-MESSAGES: [[@LINE+4]]:5: warning: argument name 'y' in comment does not match parameter name 'x'
	// CHECK: :[[@LINE-3]]:12: note: 'x' declared here			// CHECK-MESSAGES: :[[@LINE-3]]:12: note: 'x' declared here
	// CHECK: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y'			// CHECK-MESSAGES: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y'
	// CHECK: :[[@LINE-5]]:19: note: 'y' declared here			// CHECK-MESSAGES: :[[@LINE-5]]:19: note: 'y' declared here
	f(/y=/0, /z=/0);			f(/y=/0, /z=/0);
	}			}

	struct Closure {};			struct Closure {};

	template <typename T1, typename T2>			template <typename T1, typename T2>
	Closure NewCallback(void (f)(T1, T2), T1 arg1, T2 arg2) { return nullptr; }			Closure NewCallback(void (f)(T1, T2), T1 arg1, T2 arg2) { return nullptr; }

	Show All 9 Lines
	void variadic(Args&&... args);			void variadic(Args&&... args);

	template<typename... Args>			template<typename... Args>
	void variadic2(int zzz, Args&&... args);			void variadic2(int zzz, Args&&... args);

	void templates() {			void templates() {
	variadic(/xxx=/0, /yyy=/1);			variadic(/xxx=/0, /yyy=/1);
	variadic2(/zzZ=/0, /xxx=/1, /yyy=/2);			variadic2(/zzZ=/0, /xxx=/1, /yyy=/2);
	// CHECK: [[@LINE-1]]:13: warning: argument name 'zzZ' in comment does not match parameter name 'zzz'			// CHECK-MESSAGES: [[@LINE-1]]:13: warning: argument name 'zzZ' in comment does not match parameter name 'zzz'
	}			}

test/clang-tidy/check_clang_tidy.sh

This file was moved from test/clang-tidy/check_clang_tidy_fix.sh.

	#!/bin/sh			#!/bin/sh
	#			#
	# Run clang-tidy in fix mode and verify the result.			# Run clang-tidy in fix mode and verify fixes, messages or both.
	# Usage:			# Usage:
	# check_clang_tidy_fix.sh <source-file> <check-name> <temp-file> \			# check_clang_tidy.sh <source-file> <check-name> <temp-file> \
	# [optional clang-tidy arguments]			# [optional clang-tidy arguments]
	#			#
	# Example:			# Example:
	# // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s llvm-include-order %t -- -isystem $(dirname %s)/Inputs/Headers			# // RUN: $(dirname %s)/check_clang_tidy.sh %s llvm-include-order %t -- -isystem $(dirname %s)/Inputs/Headers
	# // REQUIRES: shell			# // REQUIRES: shell

	INPUT_FILE=$1			INPUT_FILE=$1
	CHECK_TO_RUN=$2			CHECK_TO_RUN=$2
	TEMPORARY_FILE=$3.cpp			TEMPORARY_FILE=$3.cpp
	# Feed the rest arguments to clang-tidy.			# Feed the rest arguments to clang-tidy.
	shift 3			shift 3
	if [ "$#" -eq 0 ] ; then			if [ "$#" -eq 0 ] ; then
	# Default to -- --std=c++11			# Default to -- --std=c++11
	set - -- --std=c++11			set - -- --std=c++11
	fi			fi

	set -o errexit			set -o errexit

				if ! grep -q 'CHECK-FIXES\\|CHECK-MESSAGES' "${INPUT_FILE}"; then
				echo "FAIL: Neither CHECK-FIXES nor CHECK-MESSAGES found in the input"
				exit 1
				fi

	# Remove the contents of the CHECK lines to avoid CHECKs matching on themselves.			# Remove the contents of the CHECK lines to avoid CHECKs matching on themselves.
	# We need to keep the comments to preserve line numbers while avoiding empty			# We need to keep the comments to preserve line numbers while avoiding empty
	# lines which could potentially trigger formatting-related checks.			# lines which could potentially trigger formatting-related checks.
	sed 's#// CHECK-[A-Z-]:.*#//#' ${INPUT_FILE} > ${TEMPORARY_FILE}			sed 's#// CHECK-[A-Z-]:.*#//#' "${INPUT_FILE}" > "${TEMPORARY_FILE}"

	clang-tidy ${TEMPORARY_FILE} -fix --checks="-*,${CHECK_TO_RUN}" "$@" \			clang-tidy "${TEMPORARY_FILE}" -fix --checks="-*,${CHECK_TO_RUN}" "$@" \
	> ${TEMPORARY_FILE}.msg 2>&1			> "${TEMPORARY_FILE}.msg" 2>&1

	FileCheck -input-file=${TEMPORARY_FILE} ${INPUT_FILE} \			if grep -q 'CHECK-FIXES' "${INPUT_FILE}"; then
				FileCheck -input-file="${TEMPORARY_FILE}" "${INPUT_FILE}" \
	-check-prefix=CHECK-FIXES -strict-whitespace			-check-prefix=CHECK-FIXES -strict-whitespace
				fi

	if grep -q CHECK-MESSAGES ${INPUT_FILE}; then			if grep -q 'CHECK-MESSAGES' "${INPUT_FILE}"; then
	FileCheck -input-file=${TEMPORARY_FILE}.msg ${INPUT_FILE} \			FileCheck -input-file="${TEMPORARY_FILE}.msg" "${INPUT_FILE}" \
	-check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning\|error}}:"			-check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning\|error}}:'
	fi			fi

test/clang-tidy/check_clang_tidy_fix.sh

This file was moved to test/clang-tidy/check_clang_tidy.sh.

test/clang-tidy/google-explicit-make-pair.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-build-explicit-make-pair %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-build-explicit-make-pair %t
	// REQUIRES: shell			// REQUIRES: shell

	namespace std {			namespace std {
	template <class T1, class T2>			template <class T1, class T2>
	struct pair {			struct pair {
	pair(T1 x, T2 y) {}			pair(T1 x, T2 y) {}
	};			};

	▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/clang-tidy/google-member-string-references.cpp

	// RUN: clang-tidy %s -checks='-*,google-runtime-member-string-references' -- \| FileCheck %s -implicit-check-not="{{warning\|error}}:"			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-member-string-references %t
				// REQUIRES: shell

	namespace std {			namespace std {
	template<typename T>			template<typename T>
	class basic_string {};			class basic_string {};

	typedef basic_string<char> string;			typedef basic_string<char> string;
	}			}

	class string {};			class string {};


	struct A {			struct A {
	const std::string &s;			const std::string &s;
	// CHECK: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants.			// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants. [google-runtime-member-string-references]
	};			};

	struct B {			struct B {
	std::string &s;			std::string &s;
	};			};

	struct C {			struct C {
	const std::string s;			const std::string s;
	};			};

	template <typename T>			template <typename T>
	struct D {			struct D {
	D();			D();
	const T &s;			const T &s;
	const std::string &s2;			const std::string &s2;
	// CHECK: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants.			// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: const string& members are dangerous.
	};			};

	D<std::string> d;			D<std::string> d;

	struct AA {			struct AA {
	const string &s;			const string &s;
	// CHECK: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants.			// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: const string& members are dangerous.
	};			};

	struct BB {			struct BB {
	string &s;			string &s;
	};			};

	struct CC {			struct CC {
	const string s;			const string s;
	};			};

	D<string> dd;			D<string> dd;

test/clang-tidy/google-memset-zero-length.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-runtime-memset %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-memset %t
	// REQUIRES: shell			// REQUIRES: shell

	void memset(void , int, __SIZE_TYPE__);			void memset(void , int, __SIZE_TYPE__);

	namespace std {			namespace std {
	using ::memset;			using ::memset;
	}			}

	▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/clang-tidy/google-overloaded-unary-and.cpp

	// RUN: clang-tidy %s -checks='-*,google-runtime-operator' -- \| FileCheck %s -implicit-check-not="{{warning\|error}}:"			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-operator %t
				// REQUIRES: shell

	struct Foo {			struct Foo {
	void *operator&();			void *operator&();
	// CHECK: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous.			// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous. [google-runtime-operator]
	};			};

	template <typename T>			template <typename T>
	struct TFoo {			struct TFoo {
	T *operator&();			T *operator&();
	// CHECK: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous.			// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not overload unary operator&
	};			};

	TFoo<int> tfoo;			TFoo<int> tfoo;

	struct Bar;			struct Bar;
	void *operator&(Bar &b);			void *operator&(Bar &b);
	// CHECK: :[[@LINE-1]]:1: warning: do not overload unary operator&, it is dangerous.			// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not overload unary operator&

				// No warnings on binary operators.
	struct Qux {			struct Qux {
	void *operator&(Qux &q); // no-warning			void *operator&(Qux &q);
	};			};

	void *operator&(Qux &q, Qux &r); // no-warning			void *operator&(Qux &q, Qux &r);

test/clang-tidy/google-readability-casting.c

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t -- -x c			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-casting %t -- -x c
	// REQUIRES: shell			// REQUIRES: shell

	void f(const char *cpc) {			void f(const char *cpc) {
	const char cpc2 = (const char)cpc;			const char cpc2 = (const char)cpc;
	// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting]			// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting]
	// CHECK-FIXES: const char *cpc2 = cpc;			// CHECK-FIXES: const char *cpc2 = cpc;
	char pc = (char)cpc;			char pc = (char)cpc;
	}			}

test/clang-tidy/google-readability-casting.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-casting %t
	// REQUIRES: shell			// REQUIRES: shell

	bool g() { return false; }			bool g() { return false; }

	enum Enum { Enum1 };			enum Enum { Enum1 };
	struct X {};			struct X {};
	struct Y : public X {};			struct Y : public X {};

	▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

test/clang-tidy/google-readability-function.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-function %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-function %t
	// REQUIRES: shell			// REQUIRES: shell

	void Method(char ) { / */ }			void Method(char ) { / */ }
	// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: all parameters should be named in a function			// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: all parameters should be named in a function
	// CHECK-FIXES: void Method(char * /unused/) { /* */ }			// CHECK-FIXES: void Method(char * /unused/) { /* */ }
	void Method2(char *) {}			void Method2(char *) {}
	// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: all parameters should be named in a function			// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: all parameters should be named in a function
	// CHECK-FIXES: void Method2(char * /unused/) {}			// CHECK-FIXES: void Method2(char * /unused/) {}
	▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

test/clang-tidy/google-readability-namespace-comments.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-namespace-comments %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-namespace-comments %t
	// REQUIRES: shell			// REQUIRES: shell

	// CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments]			// CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments]
	// CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments]			// CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments]
	namespace n1 {			namespace n1 {
	namespace n2 {			namespace n2 {

	}			}
	}			}
	// CHECK-FIXES: } // namespace n2			// CHECK-FIXES: } // namespace n2
	// CHECK-FIXES: } // namespace n1			// CHECK-FIXES: } // namespace n1


	namespace short1 { namespace short2 { } }			namespace short1 { namespace short2 { } }

test/clang-tidy/google-readability-todo.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-todo %t -config="{User: 'some user'}" --			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-todo %t -config="{User: 'some user'}" --
	// REQUIRES: shell			// REQUIRES: shell

	// TODOfix this1			// TODOfix this1
	// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO			// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
	// CHECK-FIXES: // TODO(some user): fix this1			// CHECK-FIXES: // TODO(some user): fix this1

	// TODO fix this2			// TODO fix this2
	// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO			// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
	Show All 18 Lines

test/clang-tidy/google-runtime-int.cpp

	// RUN: clang-tidy -checks=-*,google-runtime-int %s -- -x c++ 2>&1 \| FileCheck %s -implicit-check-not='{{warning:\|error:}}'			// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-int %t
				// REQUIRES: shell

	long a();			long a();
	// CHECK: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'			// CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'

	typedef unsigned long long uint64; // NOLINT			typedef unsigned long long uint64; // NOLINT

	long b(long = 1);			long b(long = 1);
	// CHECK: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'			// CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'
	// CHECK: [[@LINE-2]]:8: warning: consider replacing 'long' with 'int{{..}}'			// CHECK-MESSAGES: [[@LINE-2]]:8: warning: consider replacing 'long' with 'int{{..}}'

	template <typename T>			template <typename T>
	void tmpl() {			void tmpl() {
	T i;			T i;
	}			}

	short bar(const short, unsigned short) {			short bar(const short, unsigned short) {
	// CHECK: [[@LINE-1]]:1: warning: consider replacing 'short' with 'int16'			// CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'short' with 'int16'
	// CHECK: [[@LINE-2]]:17: warning: consider replacing 'short' with 'int16'			// CHECK-MESSAGES: [[@LINE-2]]:17: warning: consider replacing 'short' with 'int16'
	// CHECK: [[@LINE-3]]:24: warning: consider replacing 'unsigned short' with 'uint16'			// CHECK-MESSAGES: [[@LINE-3]]:24: warning: consider replacing 'unsigned short' with 'uint16'
	long double foo = 42;			long double foo = 42;
	uint64 qux = 42;			uint64 qux = 42;
	unsigned short port;			unsigned short port;

	const unsigned short bar = 0;			const unsigned short bar = 0;
	// CHECK: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16'			// CHECK-MESSAGES: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16'
	long long *baar;			long long *baar;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'
	const unsigned short &bara = bar;			const unsigned short &bara = bar;
	// CHECK: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16'			// CHECK-MESSAGES: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16'
	long const long moo = 1;			long const long moo = 1;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'
	long volatile long wat = 42;			long volatile long wat = 42;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'
	unsigned long y;			unsigned long y;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned long' with 'uint{{..}}'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned long' with 'uint{{..}}'
	unsigned long long *const tmp;			unsigned long long *const tmp;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64'
	unsigned long long *const &z = tmp;			unsigned long long *const &z = tmp;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64'
	unsigned short porthole;			unsigned short porthole;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned short' with 'uint16'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned short' with 'uint16'

	uint64 cast = (short)42;			uint64 cast = (short)42;
	// CHECK: [[@LINE-1]]:18: warning: consider replacing 'short' with 'int16'			// CHECK-MESSAGES: [[@LINE-1]]:18: warning: consider replacing 'short' with 'int16'

	#define l long			#define l long
	l x;			l x;

	tmpl<short>();			tmpl<short>();
	// CHECK: [[@LINE-1]]:8: warning: consider replacing 'short' with 'int16'			// CHECK-MESSAGES: [[@LINE-1]]:8: warning: consider replacing 'short' with 'int16'
	}			}

	void p(unsigned short port);			void p(unsigned short port);

	void qux() {			void qux() {
	short port;			short port;
	// CHECK: [[@LINE-1]]:3: warning: consider replacing 'short' with 'int16'			// CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'short' with 'int16'
	}			}

test/clang-tidy/llvm-include-order.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s llvm-include-order %t -- -isystem %S/Inputs/Headers			// RUN: $(dirname %s)/check_clang_tidy.sh %s llvm-include-order %t -- -isystem %S/Inputs/Headers
	// REQUIRES: shell			// REQUIRES: shell

	// FIXME: Investigating.			// FIXME: Investigating.
	// XFAIL: win32			// XFAIL: win32

	// CHECK-MESSAGES: [[@LINE+2]]:1: warning: #includes are not sorted properly			// CHECK-MESSAGES: [[@LINE+2]]:1: warning: #includes are not sorted properly
	#include "j.h"			#include "j.h"
	#include "gtest/foo.h"			#include "gtest/foo.h"
	Show All 32 Lines

test/clang-tidy/llvm-twine-local.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s llvm-twine-local %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s llvm-twine-local %t
	// REQUIRES: shell			// REQUIRES: shell

	namespace llvm {			namespace llvm {
	class Twine {			class Twine {
	public:			public:
	Twine(const char *);			Twine(const char *);
	Twine(int);			Twine(int);
	Twine &operator+(const Twine &);			Twine &operator+(const Twine &);
	Show All 24 Lines

test/clang-tidy/misc-bool-pointer-implicit-conversion.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-bool-pointer-implicit-conversion %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-bool-pointer-implicit-conversion %t
	// REQUIRES: shell			// REQUIRES: shell

	bool *SomeFunction();			bool *SomeFunction();
	void SomeOtherFunction(bool*);			void SomeOtherFunction(bool*);
	bool F();			bool F();
	void G(bool);			void G(bool);


	▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

test/clang-tidy/misc-swapped-arguments.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-swapped-arguments %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-swapped-arguments %t
	// REQUIRES: shell			// REQUIRES: shell

	void F(int, double);			void F(int, double);

	int SomeFunction();			int SomeFunction();

	template <typename T, typename U>			template <typename T, typename U>
	void G(T a, U b) {			void G(T a, U b) {
	Show All 35 Lines

test/clang-tidy/misc-undelegated-constructor.cpp

	// RUN: clang-tidy -checks='-*,misc-undelegated-constructor' %s -- -std=c++11 2>&1 \| FileCheck %s -implicit-check-not='{{warning:\|error:}}'			// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-undelegated-constructor %t
				// REQUIRES: shell

	struct Ctor;			struct Ctor;
	Ctor foo();			Ctor foo();

	struct Ctor {			struct Ctor {
	Ctor();			Ctor();
	Ctor(int);			Ctor(int);
	Ctor(int, int);			Ctor(int, int);
	Ctor(Ctor *i) {			Ctor(Ctor *i) {
	Ctor();			Ctor();
	// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead [misc-undelegated-constructor]
	Ctor(0);			Ctor(0);
	// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
	Ctor(1, 2);			Ctor(1, 2);
	// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
	foo();			foo();
	}			}
	};			};

	Ctor::Ctor() {			Ctor::Ctor() {
	Ctor(1);			Ctor(1);
	// CHECK: :[[@LINE-1]]:3: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: did you intend to call a delegated constructor?
	}			}

	Ctor::Ctor(int i) : Ctor(i, 1) {} // properly delegated.			Ctor::Ctor(int i) : Ctor(i, 1) {} // properly delegated.

	struct Dtor {			struct Dtor {
	Dtor();			Dtor();
	Dtor(int);			Dtor(int);
	Dtor(int, int);			Dtor(int, int);
	Dtor(Ctor *i) {			Dtor(Ctor *i) {
	Dtor();			Dtor();
	// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
	Dtor(0);			Dtor(0);
	// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
	Dtor(1, 2);			Dtor(1, 2);
	// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
	}			}
	~Dtor();			~Dtor();
	};			};

	struct Base {};			struct Base {};
	struct Derived : public Base {			struct Derived : public Base {
	Derived() { Base(); }			Derived() { Base(); }
	// CHECK: :[[@LINE-1]]:15: warning: did you intend to call a delegated constructor? A temporary object is created here instead			// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: did you intend to call a delegated constructor?
	};			};

	template <typename T>			template <typename T>
	struct TDerived : public Base {			struct TDerived : public Base {
	TDerived() { Base(); }			TDerived() { Base(); }
	};			};

	TDerived<int> t;			TDerived<int> t;

test/clang-tidy/misc-unused-raii.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-unused-raii %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-unused-raii %t
	// REQUIRES: shell			// REQUIRES: shell

	struct Foo {			struct Foo {
	Foo();			Foo();
	Foo(int);			Foo(int);
	Foo(int, int);			Foo(int, int);
	~Foo();			~Foo();
	};			};
	▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/clang-tidy/misc-use-override.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-use-override %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-use-override %t
	// REQUIRES: shell			// REQUIRES: shell

	#define ABSTRACT = 0			#define ABSTRACT = 0

	#define OVERRIDE override			#define OVERRIDE override
	#define VIRTUAL virtual			#define VIRTUAL virtual
	#define NOT_VIRTUAL			#define NOT_VIRTUAL
	#define NOT_OVERRIDE			#define NOT_OVERRIDE
	▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

test/clang-tidy/readability-braces-around-statements-few-lines.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 4}]}" --			// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 4}]}" --
	// REQUIRES: shell			// REQUIRES: shell

	void do_something(const char *) {}			void do_something(const char *) {}

	bool cond(const char *) {			bool cond(const char *) {
	return false;			return false;
	}			}

	Show All 22 Lines

test/clang-tidy/readability-braces-around-statements-same-line.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 1}]}" --			// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 1}]}" --
	// REQUIRES: shell			// REQUIRES: shell

	void do_something(const char *) {}			void do_something(const char *) {}

	bool cond(const char *) {			bool cond(const char *) {
	return false;			return false;
	}			}

	Show All 28 Lines

test/clang-tidy/readability-braces-around-statements-single-line.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 2}]}" --			// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 2}]}" --
	// REQUIRES: shell			// REQUIRES: shell

	void do_something(const char *) {}			void do_something(const char *) {}

	bool cond(const char *) {			bool cond(const char *) {
	return false;			return false;
	}			}

	Show All 25 Lines

test/clang-tidy/readability-braces-around-statements.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t
	// REQUIRES: shell			// REQUIRES: shell

	void do_something(const char *) {}			void do_something(const char *) {}

	bool cond(const char *) {			bool cond(const char *) {
	return false;			return false;
	}			}

	▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

test/clang-tidy/readability-function-size.cpp

	// RUN: rm -rf %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-function-size %t -config='{CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' -- -std=c++11
	// RUN: mkdir -p %t			// REQUIRES: shell
	// RUN: sed 's#// [A-Z-][A-Z-]:.*#//#' %s > %t/t.cpp
	// RUN: echo '{ Checks: "-*,readability-function-size", CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' > %t/.clang-tidy
	// RUN: clang-tidy %t/t.cpp -- -std=c++11 2>&1 \| FileCheck %s -implicit-check-not='{{warning:\|error:\|note:}}'

	void foo1() {			void foo1() {
	}			}

	void foo2() {;}			void foo2() {;}
	// CHECK: warning: function 'foo2' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size]
	// CHECK: note: 1 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-2]]:6: note: 1 statements (threshold 0)

	void foo3() {			void foo3() {
	;			;

	}			}
	// CHECK: warning: function 'foo3' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-4]]:6: warning: function 'foo3' exceeds recommended size/complexity
	// CHECK: note: 3 lines including whitespace and comments (threshold 0)			// CHECK-MESSAGES: :[[@LINE-5]]:6: note: 3 lines including whitespace and comments (threshold 0)
	// CHECK: note: 1 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-6]]:6: note: 1 statements (threshold 0)

	void foo4(int i) { if (i) {} else; {}			void foo4(int i) { if (i) {} else; {}
	}			}
	// CHECK: warning: function 'foo4' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-2]]:6: warning: function 'foo4' exceeds recommended size/complexity
	// CHECK: note: 1 lines including whitespace and comments (threshold 0)			// CHECK-MESSAGES: :[[@LINE-3]]:6: note: 1 lines including whitespace and comments (threshold 0)
	// CHECK: note: 3 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-4]]:6: note: 3 statements (threshold 0)
	// CHECK: note: 1 branches (threshold 0)			// CHECK-MESSAGES: :[[@LINE-5]]:6: note: 1 branches (threshold 0)

	void foo5(int i) {for(;i;)while(i)			void foo5(int i) {for(;i;)while(i)
	do;while(i);			do;while(i);
	}			}
	// CHECK: warning: function 'foo5' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-3]]:6: warning: function 'foo5' exceeds recommended size/complexity
	// CHECK: note: 2 lines including whitespace and comments (threshold 0)			// CHECK-MESSAGES: :[[@LINE-4]]:6: note: 2 lines including whitespace and comments (threshold 0)
	// CHECK: note: 7 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-5]]:6: note: 7 statements (threshold 0)
	// CHECK: note: 3 branches (threshold 0)			// CHECK-MESSAGES: :[[@LINE-6]]:6: note: 3 branches (threshold 0)

	template <typename T> T foo6(T i) {return i;			template <typename T> T foo6(T i) {return i;
	}			}
	int x = foo6(0);			int x = foo6(0);
	// CHECK: warning: function 'foo6' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-3]]:25: warning: function 'foo6' exceeds recommended size/complexity
	// CHECK: note: 1 lines including whitespace and comments (threshold 0)			// CHECK-MESSAGES: :[[@LINE-4]]:25: note: 1 lines including whitespace and comments (threshold 0)
	// CHECK: note: 1 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-5]]:25: note: 1 statements (threshold 0)

	void bar1() { [](){;;;;;;;;;;;if(1){}}();			void bar1() { [](){;;;;;;;;;;;if(1){}}();


	}			}
	// CHECK: warning: function 'bar1' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-4]]:6: warning: function 'bar1' exceeds recommended size/complexity
	// CHECK: note: 3 lines including whitespace and comments (threshold 0)			// CHECK-MESSAGES: :[[@LINE-5]]:6: note: 3 lines including whitespace and comments (threshold 0)
	// CHECK: note: 14 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-6]]:6: note: 14 statements (threshold 0)
	// CHECK: note: 1 branches (threshold 0)			// CHECK-MESSAGES: :[[@LINE-7]]:6: note: 1 branches (threshold 0)

	void bar2() { class A { void barx() {;;} }; }			void bar2() { class A { void barx() {;;} }; }
	// CHECK: warning: function 'bar2' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'bar2' exceeds recommended size/complexity
	// CHECK: note: 3 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-2]]:6: note: 3 statements (threshold 0)
	//			//
	// CHECK: warning: function 'barx' exceeds recommended size/complexity thresholds			// CHECK-MESSAGES: :[[@LINE-4]]:30: warning: function 'barx' exceeds recommended size/complexity
	// CHECK: note: 2 statements (threshold 0)			// CHECK-MESSAGES: :[[@LINE-5]]:30: note: 2 statements (threshold 0)

test/clang-tidy/readability-redundant-smartptr-get.cpp

	// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-redundant-smartptr-get %t			// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-redundant-smartptr-get %t
	// REQUIRES: shell			// REQUIRES: shell

	#define NULL __null			#define NULL __null

	namespace std {			namespace std {

	template <typename T>			template <typename T>
	struct unique_ptr {			struct unique_ptr {
	▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.shClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 15454

test/clang-tidy/arg-comments.cpp

test/clang-tidy/check_clang_tidy.sh

test/clang-tidy/check_clang_tidy_fix.sh

test/clang-tidy/google-explicit-make-pair.cpp

test/clang-tidy/google-member-string-references.cpp

test/clang-tidy/google-memset-zero-length.cpp

test/clang-tidy/google-overloaded-unary-and.cpp

test/clang-tidy/google-readability-casting.c

test/clang-tidy/google-readability-casting.cpp

test/clang-tidy/google-readability-function.cpp

test/clang-tidy/google-readability-namespace-comments.cpp

test/clang-tidy/google-readability-todo.cpp

test/clang-tidy/google-runtime-int.cpp

test/clang-tidy/llvm-include-order.cpp

test/clang-tidy/llvm-twine-local.cpp

test/clang-tidy/misc-bool-pointer-implicit-conversion.cpp

test/clang-tidy/misc-swapped-arguments.cpp

test/clang-tidy/misc-undelegated-constructor.cpp

test/clang-tidy/misc-unused-raii.cpp

test/clang-tidy/misc-use-override.cpp

test/clang-tidy/readability-braces-around-statements-few-lines.cpp

test/clang-tidy/readability-braces-around-statements-same-line.cpp

test/clang-tidy/readability-braces-around-statements-single-line.cpp

test/clang-tidy/readability-braces-around-statements.cpp

test/clang-tidy/readability-function-size.cpp

test/clang-tidy/readability-redundant-smartptr-get.cpp

[clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
ClosedPublic