[Sema] Add -wtest global flag that silences -Wself-assign for overloaded operators.

[lebedev.ri]

Summary

Credit for the idea goes to @rjmccall.

As tests show, only the overloaded non-field assign is silenced by it.

Testing: $ ninja check-clang-sema check-clang-semacxx check-clang

[lebedev.ri]

• Don't mis-spell the name of the flag.

FIXME: So do we want it to be -Wtests, -Wtest, or we really want it to be -wtest ?

[lebedev.ri]

Actually make it -wtest (all lowercase).

[• Quuxplusone]

I don't understand the spelling of this option. You spell it -wtest (because rjmccall suggested that spelling); but for my money it should be spelled -Wno-self-assign-nonfield.
Also, if you go this route, you miss the true positive reported by someone on the other patch, where the self-assignment involved a local variable named color.
Sorry I can't find the example right now. You'd have to trawl through all the patches opened on this subject in the past couple of weeks.

[lebedev.ri]

In D45685#1068981, @Quuxplusone wrote:

I don't understand the spelling of this option. You spell it -wtest (because rjmccall suggested that spelling); but for my money it should be spelled -Wno-self-assign-nonfield.

You did read the documentation change, right?

Also, if you go this route, you miss the true positive reported by someone on the other patch, where the self-assignment involved a local variable named color.

Uhm, why? -wtest is not the default, so the warning would still have been issued there.

Sorry I can't find the example right now. You'd have to trawl through all the patches opened on this subject in the past couple of weeks.

[dblaikie]

I'm not sure this is a practical direction to pursue - though perhaps
others disagree.

It's likely non-trivial to plumb a flag through most build systems to be
applied only to test code (& likely would suppress the warning in headers
only included in test code - so for example, in a header-only library if
the user ran their tests they wouldn't see the warning, but when the users
code was used in some other production code it might warn (& possibly break
the build if -Werror is in use))

[lebedev.ri]

In D45685#1069040, @dblaikie wrote:

I'm not sure this is a practical direction to pursue - though perhaps
others disagree.

It's likely non-trivial to plumb a flag through most build systems to be
applied only to test code

I'm sorry, I don't understand.

If you don't separate between source code and *_test.cpp sources, sure,
you will loose the warning coverage either way.

What difference is there between passing -wtest and passing -Wno-self-assign-overloaded?
Just pass it alongside with the googletest include paths so to speak.

(& likely would suppress the warning in headers
only included in test code - so for example, in a header-only library if
the user ran their tests they wouldn't see the warning, but when the users
code was used in some other production code it might warn (& possibly break
the build if -Werror is in use))

Could you please explain how it is not an issue if this would be a -Wno-self-assign-overloaded?

[lebedev.ri]

Uuuh, the fact that phab posts the top-postings, but silently ignores inline replies is annoying.

lebedev.ri added a comment.

In https://reviews.llvm.org/D45685#1069040, @dblaikie wrote:

I'm not sure this is a practical direction to pursue - though perhaps
others disagree.

It's likely non-trivial to plumb a flag through most build systems to be
applied only to test code

I'm sorry, I don't understand.

If you don't separate between source code and *_test.cpp sources, sure,
you will loose the warning coverage either way.

What difference is there between passing -wtest and passing
-Wno-self-assign-overloaded?

Not much, if any.

Ok, so this was a non-argument then?

Just pass it alongside with the googletest include paths so to speak.

But build systems don't necessarily expose that kind of ability. (For
example, googletest (not the only kind of test suite/code) is checked into
the LLVM codebase like another library - so depending on it is just another
library dependency, not a special "test" library dependency).

It's a bit hard to talk about all and every spherical build system / project
in the vacuum, because there is an infinite number of possibilities.
Of course some build systems are horribly designed, and it will be hard to
do that there. But I sure hope that isn't the case in most of the cases.
It might be more productive to talk about a few good known realities.

In llvm's case you would simply add -wtest (or -Wno-self-assign-overloaded)
in here https://github.com/llvm-mirror/llvm/blob/2a6cf85828509e89e18739e5f4b9a958820d66d4/cmake/modules/AddLLVM.cmake#L1079-L1085
and around here https://github.com/llvm-mirror/libcxx/blob/73e00f8321b13559b3c41f6656686d980fe92fbe/utils/libcxx/test/config.py#L914
I'd say that is rather trivial.

[thakis]

+1 to just adding a dedicated Wno flag for the new warning instead of
coming up with this new spelling.

[rjmccall]

The goal of having a unified option is that you can uniformly suppress warnings that don't always make sense in unit tests. It's future-proofing against the addition of other warnings (probably C++ warnings) that might not make sense for unit tests, like extending the x &= x warning (which is not in -Wself-assign) to user-defined operators. You don't think you would be able to take advantage of that? Because -Wno-self-assign-overloaded-nonfield is rather, uh, pretty precisely targeted for exactly that use case; I can't imagine why someone would use -Wself-assign-overloaded-nofield *positively*, or even *negatively* for any purpose besides suppressing a unit-test problem.

If you can't reasonably just add this to unit tests, of course you can just add it globally, but that's just as true for -wtestas it would be for -Wno-self-assign-overloaded-nonfield, and the former seems more self-descriptive of the problem when it appears in a general CFLAGS line: you don't have a reasonable way of suppressing it for just unit tests so you have to suppress it globally.

[rjmccall]

I'm sorry, that warning *is* in self-assign, although I'm not sure it should be.

[rjmccall]

Let me try to summarize where I think we are.

1. I think it’s now generally agreed that this is a useful warning —

certainly for field assignments, but we also have (at least?) one example
with a local variable.

2. It’s also generally agreed that this warning has a problem with unit

tests and that we should provide a compiler option to suppress.

3. There isn’t really a middle-point between case-by-case suppression (by

rewriting the RHS to avoid the warning) and file-by-file (compiler option)
suppression. We don’t know how to distinguish the unit-test false positives
from the local-variable true positive.

4. Whatever the file-by-file suppression is, it would be best for build

systems to target it narrowly at their unit-test code; but we also have to
acknowledge that that’s not always straightforward, and so the suppression
should be narrowly-targeted on the compiler side as well, just in case the
suppression does have to be more global.

5. Roman and I are suggesting that the file-by-file suppression should not

be specific to this warning but instead should be a more generic way of
disabling warnings that are known to be problematic in unit tests. We could
then recommend that option to project owners as a single mitigation rather
than forcing them to maintain a growing list of test-directed warning
suppressions.

6. Using a more general mechanism seems advisable because we are already

considering extending some other warnings to cover user-defined operators,
and all such warnings have the potential of running afoul of unit tests.
(This is something that will require careful thought because user-defined
operators need not have their conventional meaning. However, any
semantics-based suppression will almost certainly have different
characteristics from a test-directed suppression. For example,
test-directed suppression for self-assign need not suppress warnings about
fields, whereas a semantics-based suppression should.)

John.

[brooksmoses]

Thanks for the summary, John. To confirm, I found two examples of bugs involving local variables, as well as the field-based examples. And, indeed, all of the false positives were in unit tests.

[lebedev.ri]

@brooksmoses The simple -Wno-self-assign-overloaded variant (D45766) has landed, so the issue should be resolved?

Not sure what to do with this differential, should i abandon it until there is more interest for such functionality?

[rsmith]

I would feel a lot more comfortable adding a -wtest flag if we had more than one warning that it would control. If there's really only one warning out of >600 that qualifies for this treatment, I really don't think we have a good argument to introduce a new feature here, and it'll just be dead weight we're carrying forever. My inclination is to say that the single -Wno- flag is sufficient until we actually have multiple warnings that this would control, and this is a premature generalization until that point. ("We're just about to add these warnings" carries a lot more weight for me here than "We have ideas of warnings we might add", but if we're in the former situation, there seems to be no harm in waiting.)

I'm also concerned about the deployability and utility of this feature. Identifying "test code" is not going to be easy in a lot of build systems. Even if successfully deployed, this would mean that refactorings moving code between files (eg, out of test code into shared infrastructure code) could affect whether clang accepts the program (eg, under -Werror), which seems pretty undesirable. And likewise, tests that check that (for instance) certain macro expansions produce valid code would stop being reliable -- the expansion might be valid in test code but not valid in non-test code. But for me that's a minor concern at worst: if there are users who are happy with the tradeoffs here, I'd be OK with us carrying support for them. The major concern here is: are there users who would enable this feature? (Briefly taking off my Clang hat and putting on my Google hat, I think we -- as the people who originally had major problems with the expanded -Wself-assign warning -- would be very unlikely to ever use -wtest because of the refactoring issue.)

Finally, let's assume that this is successful and we end up with dozens of warnings covered by -wtest. How confident are we that we're not going to want a case-by-case way to turn them back on? That is, how sure are we that this isn't just another warning group (albeit one that only really makes sense to turn off, not to turn on)? For -w, this isn't really a concern, because -w is very much a "just compile it, I do not care about bugs or code quality" flag which doesn't really make sense to only partially deploy.

include/clang/Basic/Diagnostic.td

102–104

This does not seem like it should ever be necessary.

docs/ReleaseNotes.rst

 Major New Features
 ------------------
 
 -  ...
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- ``-wtest`` flag was added. It is advised to pass it when building tests.
+  It disables some diagnostics for code that is very likely intentional in
+  tests, but is an issue elsewhere, e.g. self-assignment (``-Wself-assign``).
+
 - ``-Wc++98-compat-extra-semi`` is a new flag, which was previously inseparable
   from ``-Wc++98-compat-pedantic``. The latter still controls the new flag.
 
 - ``-Wextra-semi`` now also controls ``-Wc++98-compat-extra-semi``.
   Please do note that if you pass ``-Wno-c++98-compat-pedantic``, it implies
   ``-Wno-c++98-compat-extra-semi``, so if you want that diagnostic, you need
   to explicitly re-enable it (e.g. by appending ``-Wextra-semi``).
 
 - ``-Wself-assign`` and ``-Wself-assign-field`` were extended to diagnose
   self-assignment operations using overloaded operators (i.e. classes).
   If you are doing such an assignment intentionally, e.g. in a unit test for
-  a data structure, the warning can be suppressed by adding ``*&`` to the
-  right-hand side or casting it to the appropriate reference type.
+  a data structure, the ``-Wself-assign`` warning can be suppressed by
+  passing ``-wtest`` flag, or adding ``*&`` to the right-hand side or
+  casting it to the appropriate reference type.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 - Clang binary and libraries have been renamed from 7.0 to 7.
   For example, the ``clang`` binary will be called ``clang-7``
   instead of ``clang-7.0``.
 

docs/UsersManual.rst

 .. option:: -Wno-foo
 
   Disable warning "foo".
 
 .. option:: -w
 
   Disable all diagnostics.
 
+.. option:: -wtest
+
+  Disable some diagnostics that are very likely a false-positives in test code.
+
 .. option:: -Weverything
 
   :ref:`Enable all diagnostics. <diagnostics_enable_everything>`
 
 .. option:: -pedantic
 
   Warn on language extensions.
 

include/clang/AST/ASTDiagnostic.h

 #ifndef LLVM_CLANG_AST_ASTDIAGNOSTIC_H
 #define LLVM_CLANG_AST_ASTDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define ASTSTART
 #include "clang/Basic/DiagnosticASTKinds.inc"
 #undef DIAG
       NUM_BUILTIN_AST_DIAGNOSTICS
     };
   }  // end namespace diag
   
   /// \brief DiagnosticsEngine argument formatting function for diagnostics that

include/clang/AST/CommentDiagnostic.h

 #ifndef LLVM_CLANG_AST_COMMENTDIAGNOSTIC_H
 #define LLVM_CLANG_AST_COMMENTDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define COMMENTSTART
 #include "clang/Basic/DiagnosticCommentKinds.inc"
 #undef DIAG
       NUM_BUILTIN_COMMENT_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif
 

include/clang/Basic/Diagnostic.h

public:
     unsigned WarningsAsErrors : 1;
 
     // Treat errors like fatal errors.
     unsigned ErrorsAsFatal : 1;
 
     // Suppress warnings in system headers.
     unsigned SuppressSystemWarnings : 1;
 
+    // Suppress some warnings that are false-positives for tests.
+    unsigned TailorForTests : 1;
+
     // Map extensions to warnings or errors?
     diag::Severity ExtBehavior = diag::Severity::Ignored;
 
     DiagState()
         : IgnoreAllWarnings(false), EnableAllWarnings(false),
           WarningsAsErrors(false), ErrorsAsFatal(false),
-          SuppressSystemWarnings(false) {}
+          SuppressSystemWarnings(false), TailorForTests(false) {}
 
     using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator;
     using const_iterator =
         llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator;
 
     void setMapping(diag::kind Diag, DiagnosticMapping Info) {
       DiagMap[Diag] = Info;
     }
public:
   /// \brief When set to true mask warnings that come from system headers.
   void setSuppressSystemWarnings(bool Val) {
     GetCurDiagState()->SuppressSystemWarnings = Val;
   }
   bool getSuppressSystemWarnings() const {
     return GetCurDiagState()->SuppressSystemWarnings;
   }
 
-  /// \brief Suppress all diagnostics, to silence the front end when we 
+  /// \brief When set to true some warnings that are likely to be
+  ///        false-positives in tests are not issued.
+  void setTailorForTests(bool Val) { GetCurDiagState()->TailorForTests = Val; }
+  bool getTailorForTests() const { return GetCurDiagState()->TailorForTests; }
+
+  /// \brief Suppress all diagnostics, to silence the front end when we
   /// know that we don't want any more diagnostics to be passed along to the
   /// client
   void setSuppressAllDiagnostics(bool Val = true) { 
     SuppressAllDiagnostics = Val; 
   }
   bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; }
 
   /// \brief Set type eliding, to skip outputting same types occurring in

include/clang/Basic/Diagnostic.td

class Diagnostic<string text, DiagClass DC, Severity defaultmapping> {
   /// Component is specified by the file with a big let directive.
   string         Component = ?;
   string         Text = text;
   DiagClass      Class = DC;
   SFINAEResponse SFINAE = SFINAE_Suppress;
   bit            AccessControl = 0;
   bit            WarningNoWerror = 0;
   bit            ShowInSystemHeader = 0;
+  bit            HideInTests = 0;
   Severity       DefaultSeverity = defaultmapping;
   DiagGroup      Group;
   string         CategoryName = "";
 }
 
 class SFINAEFailure {
   SFINAEResponse SFINAE = SFINAE_SubstitutionFailure;
 }
 class NoSFINAE {
   SFINAEResponse SFINAE = SFINAE_Report;
 }
 class AccessControl {
   SFINAEResponse SFINAE = SFINAE_AccessControl;
 }
 
 class ShowInSystemHeader {
   bit ShowInSystemHeader = 1;
 }
 
 class SuppressInSystemHeader {
   bit ShowInSystemHeader = 0;
 }
 
+class ShowInTests {
+  bit HideInTests = 0;
+}
+
+class SuppressInTests {
+  bit HideInTests = 1;
+}
+
 // FIXME: ExtWarn and Extension should also be SFINAEFailure by default.
 class Error<string str>     : Diagnostic<str, CLASS_ERROR, SEV_Error>, SFINAEFailure {
   bit ShowInSystemHeader = 1;
 }
 // Warnings default to on (but can be default-off'd with DefaultIgnore).
 // This is used for warnings about questionable code; warnings about
 // accepted language extensions should use Extension or ExtWarn below instead.
 class Warning<string str>   : Diagnostic<str, CLASS_WARNING, SEV_Warning>;

include/clang/Basic/DiagnosticIDs.h

namespace diag {
 
     class CustomDiagInfo;
 
     /// \brief All of the diagnostics that can be emitted by the frontend.
     typedef unsigned kind;
 
     // Get typedefs for common diagnostics.
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,CATEGORY,NOWERROR,SHOWINSYSHEADER) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, CATEGORY,      \
+             NOWERROR, SHOWINSYSHEADER, HIDEINTESTS)                           \
+  ENUM,
 #define COMMONSTART
 #include "clang/Basic/DiagnosticCommonKinds.inc"
       NUM_BUILTIN_COMMON_DIAGNOSTICS
 #undef DIAG
     };
 
     /// Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs
     /// to either Ignore (nothing), Remark (emit a remark), Warning

include/clang/Basic/DiagnosticOptions.def

 #endif
 
 #ifndef SEMANTIC_ENUM_DIAGOPT
 #  define SEMANTIC_ENUM_DIAGOPT(Name, Type, Bits, Default) \
      ENUM_DIAGOPT(Name, Type, Bits, Default)
 #endif
 
 SEMANTIC_DIAGOPT(IgnoreWarnings, 1, 0)   /// -w
+SEMANTIC_DIAGOPT(TailorForTest, 1, 0)    /// -wtest
 DIAGOPT(NoRewriteMacros, 1, 0)  /// -Wno-rewrite-macros
 DIAGOPT(Pedantic, 1, 0)         /// -pedantic
 DIAGOPT(PedanticErrors, 1, 0)   /// -pedantic-errors
 DIAGOPT(ShowColumn, 1, 1)       /// Show column number on diagnostics.
 DIAGOPT(ShowLocation, 1, 1)     /// Show source location information.
 DIAGOPT(AbsolutePath, 1, 0)     /// Use absolute paths.
 DIAGOPT(ShowCarets, 1, 1)       /// Show carets in diagnostics.
 DIAGOPT(ShowFixits, 1, 1)       /// Show fixit information.

include/clang/Basic/DiagnosticSemaKinds.td

def warn_overloaded_shift_in_comparison :Warning<
   InGroup<OverloadedShiftOpParentheses>;
 def note_evaluate_comparison_first :Note<
   "place parentheses around comparison expression to evaluate it first">;
 
 def warn_addition_in_bitshift : Warning<
   "operator '%0' has lower precedence than '%1'; "
   "'%1' will be evaluated first">, InGroup<ShiftOpParentheses>;
 
-def warn_self_assignment : Warning<
+def warn_self_assignment_builtin : Warning<
   "explicitly assigning value of variable of type %0 to itself">,
   InGroup<SelfAssignment>, DefaultIgnore;
+def warn_self_assignment_overloaded: Warning<warn_self_assignment_builtin.Text>,
+  InGroup<SelfAssignment>, DefaultIgnore, SuppressInTests;
 def warn_self_move : Warning<
   "explicitly moving variable of type %0 to itself">,
   InGroup<SelfMove>, DefaultIgnore;
 
 def warn_redundant_move_on_return : Warning<
   "redundant move in return statement">,
   InGroup<RedundantMove>, DefaultIgnore;
 def warn_pessimizing_move_on_return : Warning<

include/clang/CrossTU/CrossTUDiagnostic.h

 #define LLVM_CLANG_CROSSTU_CROSSTUDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
 namespace diag {
 enum {
 #define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
-             SHOWINSYSHEADER, CATEGORY)                                        \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
   ENUM,
 #define CROSSTUSTART
 #include "clang/Basic/DiagnosticCrossTUKinds.inc"
 #undef DIAG
   NUM_BUILTIN_CROSSTU_DIAGNOSTICS
 };
 } // end namespace diag
 } // end namespace clang
 
 #endif // LLVM_CLANG_FRONTEND_FRONTENDDIAGNOSTIC_H

include/clang/Driver/DriverDiagnostic.h

 #ifndef LLVM_CLANG_DRIVER_DRIVERDIAGNOSTIC_H
 #define LLVM_CLANG_DRIVER_DRIVERDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define DRIVERSTART
 #include "clang/Basic/DiagnosticDriverKinds.inc"
 #undef DIAG
       NUM_BUILTIN_DRIVER_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

include/clang/Driver/Options.td

 def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[DriverOption]>,
   HelpText<"Verify the binary representation of debug output">;
 def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>;
 def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>;
 def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>;
 def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">;
 def whatsloaded : Flag<["-"], "whatsloaded">;
 def whyload : Flag<["-"], "whyload">;
+def wtest : Flag<["-"], "wtest">, HelpText<"Disable some diagnostics that are likely false-positives in tests">, Flags<[CC1Option]>;
 def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>;
 def x : JoinedOrSeparate<["-"], "x">, Flags<[DriverOption,CC1Option]>,
   HelpText<"Treat subsequent input files as having type <language>">,
   MetaVarName<"<language>">;
 def y : Joined<["-"], "y">;
 
 def fintegrated_as : Flag<["-"], "fintegrated-as">, Flags<[DriverOption]>,
                      Group<f_Group>, HelpText<"Enable the integrated assembler">;

include/clang/Frontend/FrontendDiagnostic.h

 #ifndef LLVM_CLANG_FRONTEND_FRONTENDDIAGNOSTIC_H
 #define LLVM_CLANG_FRONTEND_FRONTENDDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define FRONTENDSTART
 #include "clang/Basic/DiagnosticFrontendKinds.inc"
 #undef DIAG
       NUM_BUILTIN_FRONTEND_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

include/clang/Lex/LexDiagnostic.h

 #ifndef LLVM_CLANG_LEX_LEXDIAGNOSTIC_H
 #define LLVM_CLANG_LEX_LEXDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define LEXSTART
 #include "clang/Basic/DiagnosticLexKinds.inc"
 #undef DIAG
       NUM_BUILTIN_LEX_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

include/clang/Parse/ParseDiagnostic.h

 #ifndef LLVM_CLANG_PARSE_PARSEDIAGNOSTIC_H
 #define LLVM_CLANG_PARSE_PARSEDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define PARSESTART
 #include "clang/Basic/DiagnosticParseKinds.inc"
 #undef DIAG
       NUM_BUILTIN_PARSE_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

include/clang/Sema/SemaDiagnostic.h

 #ifndef LLVM_CLANG_SEMA_SEMADIAGNOSTIC_H
 #define LLVM_CLANG_SEMA_SEMADIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define SEMASTART
 #include "clang/Basic/DiagnosticSemaKinds.inc"
 #undef DIAG
       NUM_BUILTIN_SEMA_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

include/clang/Serialization/SerializationDiagnostic.h

 #ifndef LLVM_CLANG_SERIALIZATION_SERIALIZATIONDIAGNOSTIC_H
 #define LLVM_CLANG_SERIALIZATION_SERIALIZATIONDIAGNOSTIC_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
   namespace diag {
     enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
+#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  ENUM,
 #define SERIALIZATIONSTART
 #include "clang/Basic/DiagnosticSerializationKinds.inc"
 #undef DIAG
       NUM_BUILTIN_SERIALIZATION_DIAGNOSTICS
     };
   }  // end namespace diag
 }  // end namespace clang
 
 #endif

include/clang/Tooling/Refactoring/RefactoringDiagnostic.h

 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/PartialDiagnostic.h"
 
 namespace clang {
 namespace diag {
 enum {
 #define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
-             SHOWINSYSHEADER, CATEGORY)                                        \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
   ENUM,
 #define REFACTORINGSTART
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
 #undef DIAG
   NUM_BUILTIN_REFACTORING_DIAGNOSTICS
 };
 } // end namespace diag
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTORING_REFACTORINGDIAGNOSTIC_H

lib/Basic/DiagnosticIDs.cpp

 
 struct StaticDiagInfoRec {
   uint16_t DiagID;
   unsigned DefaultSeverity : 3;
   unsigned Class : 3;
   unsigned SFINAE : 2;
   unsigned WarnNoWerror : 1;
   unsigned WarnShowInSystemHeader : 1;
+  unsigned WarnHideInTests : 1;
   unsigned Category : 6;
 
   uint16_t OptionGroupIndex;
 
   uint16_t DescriptionLen;
   const char *DescriptionStr;
 
   unsigned getOptionGroupIndex() const {

 VALIDATE_DIAG_SIZE(REFACTORING)
 #undef VALIDATE_DIAG_SIZE
 #undef STRINGIFY_NAME
 
 } // namespace anonymous
 
 static const StaticDiagInfoRec StaticDiagInfo[] = {
 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR,     \
-             SHOWINSYSHEADER, CATEGORY)                                        \
-  {                                                                            \
-    diag::ENUM, DEFAULT_SEVERITY, CLASS, DiagnosticIDs::SFINAE, NOWERROR,      \
-        SHOWINSYSHEADER, CATEGORY, GROUP, STR_SIZE(DESC, uint16_t), DESC       \
-  }                                                                            \
-  ,
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  {diag::ENUM, DEFAULT_SEVERITY,         CLASS,       DiagnosticIDs::SFINAE,   \
+   NOWERROR,   SHOWINSYSHEADER,          HIDEINTESTS, CATEGORY,                \
+   GROUP,      STR_SIZE(DESC, uint16_t), DESC},
 #include "clang/Basic/DiagnosticCommonKinds.inc"
 #include "clang/Basic/DiagnosticDriverKinds.inc"
 #include "clang/Basic/DiagnosticFrontendKinds.inc"
 #include "clang/Basic/DiagnosticSerializationKinds.inc"
 #include "clang/Basic/DiagnosticLexKinds.inc"
 #include "clang/Basic/DiagnosticParseKinds.inc"
 #include "clang/Basic/DiagnosticASTKinds.inc"
 #include "clang/Basic/DiagnosticCommentKinds.inc"
DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
   // If we are in a system header, we ignore it. We look at the diagnostic class
   // because we also want to ignore extensions and warnings in -Werror and
   // -pedantic-errors modes, which *map* warnings/extensions to errors.
   if (State->SuppressSystemWarnings && !ShowInSystemHeader && Loc.isValid() &&
       Diag.getSourceManager().isInSystemHeader(
           Diag.getSourceManager().getExpansionLoc(Loc)))
     return diag::Severity::Ignored;
 
+  // Don't show some diagnostics when -wtest is passed.
+  if (State->TailorForTests && GetDiagInfo(DiagID) &&
+      GetDiagInfo(DiagID)->WarnHideInTests && Loc.isValid())
+    return diag::Severity::Ignored;
+
   return Result;
 }
 
 #define GET_DIAG_ARRAYS
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_DIAG_ARRAYS
 
 namespace {

lib/Basic/Warnings.cpp

Diags.Report(diag::warn_unknown_diag_option)
     << (Flavor == diag::Flavor::WarningOrError ? 0 : 1) << (Prefix.str() += Opt)
     << !Suggestion.empty() << (Prefix.str() += Suggestion);
 }
 
 void clang::ProcessWarningOptions(DiagnosticsEngine &Diags,
                                   const DiagnosticOptions &Opts,
                                   bool ReportDiags) {
   Diags.setSuppressSystemWarnings(true);  // Default to -Wno-system-headers
+  Diags.setTailorForTests(Opts.TailorForTest);
   Diags.setIgnoreAllWarnings(Opts.IgnoreWarnings);
   Diags.setShowOverloads(Opts.getShowOverloads());
 
   Diags.setElideType(Opts.ElideType);
   Diags.setPrintTemplateTree(Opts.ShowTemplateTree);
   Diags.setShowColors(Opts.ShowColors);
  
   // Handle -ferror-limit
for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i) {
 
       // -Wsystem-headers is a special case, not driven by the option table.  It
       // cannot be controlled with -Werror.
       if (Opt == "system-headers") {
         if (SetDiagnostic)
           Diags.setSuppressSystemWarnings(!isPositive);
         continue;
       }
-      
       // -Weverything is a special case as well.  It implicitly enables all
       // warnings, including ones not explicitly in a warning group.
       if (Opt == "everything") {
         if (SetDiagnostic) {
           if (isPositive) {
             Diags.setEnableAllWarnings(true);
           } else {
             Diags.setEnableAllWarnings(false);

lib/Driver/Driver.cpp

if (HasConfigFile)
     }
 
   // FIXME: This stuff needs to go into the Compilation, not the driver.
   bool CCCPrintPhases;
 
   // Silence driver warnings if requested
   Diags.setIgnoreAllWarnings(Args.hasArg(options::OPT_w));
 
+  // Silence some warnings that are likely false-positives in tests.
+  Diags.setTailorForTests(Args.hasArg(options::OPT_wtest));
+
   // -no-canonical-prefixes is used very early in main.
   Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
 
   // Ignore -pipe.
   Args.ClaimAllArgs(options::OPT_pipe);
 
   // Extract -ccc args.
   //

lib/Frontend/CompilerInvocation.cpp

bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
                                 bool DefaultDiagColor, bool DefaultShowOpt) {
   bool Success = true;
 
   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
   if (Arg *A =
           Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
     Opts.DiagnosticSerializationFile = A->getValue();
   Opts.IgnoreWarnings = Args.hasArg(OPT_w);
+  Opts.TailorForTest = Args.hasArg(OPT_wtest);
   Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
   Opts.Pedantic = Args.hasArg(OPT_pedantic);
   Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
   Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
   Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
   Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
                                  OPT_fno_show_column,
                                  /*Default=*/true);

lib/Sema/SemaExpr.cpp

static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
   case tok::kw___extension__: Opc = UO_Extension; break;
   }
   return Opc;
 }
 
 /// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
 /// This warning suppressed in the event of macro expansions.
 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
-                                   SourceLocation OpLoc) {
+                                   SourceLocation OpLoc, bool IsBuiltin) {
   if (S.inTemplateInstantiation())
     return;
   if (S.isUnevaluatedContext())
     return;
   if (OpLoc.isInvalid() || OpLoc.isMacroID())
     return;
   LHSExpr = LHSExpr->IgnoreParenImpCasts();
   RHSExpr = RHSExpr->IgnoreParenImpCasts();
static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
   if (LHSDecl != RHSDecl)
     return;
   if (LHSDecl->getType().isVolatileQualified())
     return;
   if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
     if (RefTy->getPointeeType().isVolatileQualified())
       return;
 
-  S.Diag(OpLoc, diag::warn_self_assignment)
-      << LHSDeclRef->getType()
-      << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
+  S.Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
+                          : diag::warn_self_assignment_overloaded)
+      << LHSDeclRef->getType() << LHSExpr->getSourceRange()
+      << RHSExpr->getSourceRange();
 }
 
 /// Check if a bitwise-& is performed on an Objective-C pointer.  This
 /// is usually indicative of introspection within the Objective-C pointer.
 static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
                                           SourceLocation OpLoc) {
   if (!S.getLangOpts().ObjC1)
     return;
ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
   case BO_Assign:
     ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType());
     if (getLangOpts().CPlusPlus &&
         LHS.get()->getObjectKind() != OK_ObjCProperty) {
       VK = LHS.get()->getValueKind();
       OK = LHS.get()->getObjectKind();
     }
     if (!ResultTy.isNull()) {
-      DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc);
+      DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
       DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc);
     }
     RecordModifiableNonNullParam(*this, LHS.get());
     break;
   case BO_PtrMemD:
   case BO_PtrMemI:
     ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
                                             Opc == BO_PtrMemI);
ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
   case BO_ShrAssign:
     CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true);
     CompLHSTy = CompResultTy;
     if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
       ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
     break;
   case BO_AndAssign:
   case BO_OrAssign: // fallthrough
-    DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc);
+    DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
     LLVM_FALLTHROUGH;
   case BO_XorAssign:
     CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, Opc);
     CompLHSTy = CompResultTy;
     if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
       ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
     break;
   case BO_Comma:
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
   switch (Opc) {
   case BO_Assign:
   case BO_DivAssign:
   case BO_RemAssign:
   case BO_SubAssign:
   case BO_AndAssign:
   case BO_OrAssign:
   case BO_XorAssign:
-    DiagnoseSelfAssignment(S, LHS, RHS, OpLoc);
+    DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
     CheckIdentityFieldAssignment(LHS, RHS, OpLoc, S);
     break;
   default:
     break;
   }
 
   // Find all of the overloaded operators visible from this
   // point. We perform both an operator-name lookup from the local

test/Sema/warn-self-assign-builtin-warn-test.c

+// RUN: %clang_cc1 -fsyntax-only -Wself-assign -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wself-assign -wtest -verify %s
+
+void var() {
+  int a;
+#ifndef SILENCE
+  a = a; // expected-warning{{explicitly assigning}}
+#else
+  // expected-no-diagnostics
+  a = a;
+#endif
+}
+
+struct S {};
+
+void str() {
+  struct S a;
+#ifndef SILENCE
+  a = a; // expected-warning{{explicitly assigning}}
+#else
+  // expected-no-diagnostics
+  a = a;
+#endif
+}

test/SemaCXX/warn-self-assign-builtin-warn-test.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wself-assign -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wself-assign -wtest -verify %s
+
+void f() {
+  int a;
+#ifndef SILENCE
+  a = a; // expected-warning{{explicitly assigning}}
+#else
+  // expected-no-diagnostics
+  a = a;
+#endif
+}

test/SemaCXX/warn-self-assign-field-builtin-warn-test.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -wtest -verify %s
+
+struct C {
+  int a;
+
+  void f() {
+#ifndef SILENCE
+    a = a; // expected-warning{{assigning field to itself}}
+#else
+    // expected-no-diagnostics
+    a = a;
+#endif
+  }
+};

test/SemaCXX/warn-self-assign-field-overloaded-warn-test.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -wtest -verify %s
+
+struct S {};
+
+struct C {
+  S a;
+
+  void f() {
+#ifndef SILENCE
+    a = a; // expected-warning{{assigning field to itself}}
+#else
+    // expected-no-diagnostics
+    a = a;
+#endif
+  }
+};

test/SemaCXX/warn-self-assign-overloaded-warn-test.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wself-assign -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wself-assign -wtest -verify -DSILENCE %s
+
+struct S {};
+
+void f() {
+  S a;
+#ifndef SILENCE
+  a = a; // expected-warning{{explicitly assigning}}
+#else
+  // expected-no-diagnostics
+  a = a;
+#endif
+}

tools/diagtool/DiagnosticNames.cpp

 llvm::ArrayRef<DiagnosticRecord> diagtool::getBuiltinDiagnosticsByName() {
   return llvm::makeArrayRef(BuiltinDiagnosticsByName);
 }
 
 
 // FIXME: Is it worth having two tables, especially when this one can get
 // out of sync easily?
 static const DiagnosticRecord BuiltinDiagnosticsByID[] = {
-#define DIAG(ENUM,CLASS,DEFAULT_MAPPING,DESC,GROUP,               \
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY)            \
-  { #ENUM, diag::ENUM, STR_SIZE(#ENUM, uint8_t) },
+#define DIAG(ENUM, CLASS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR,      \
+             SHOWINSYSHEADER, HIDEINTESTS, CATEGORY)                           \
+  {#ENUM, diag::ENUM, STR_SIZE(#ENUM, uint8_t)},
 #include "clang/Basic/DiagnosticCommonKinds.inc"
 #include "clang/Basic/DiagnosticCrossTUKinds.inc"
 #include "clang/Basic/DiagnosticDriverKinds.inc"
 #include "clang/Basic/DiagnosticFrontendKinds.inc"
 #include "clang/Basic/DiagnosticSerializationKinds.inc"
 #include "clang/Basic/DiagnosticLexKinds.inc"
 #include "clang/Basic/DiagnosticParseKinds.inc"
 #include "clang/Basic/DiagnosticASTKinds.inc"

utils/TableGen/ClangDiagnosticsEmitter.cpp

for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     else
       OS << ", false";
 
     if (R.getValueAsBit("ShowInSystemHeader"))
       OS << ", true";
     else
       OS << ", false";
 
+    if (R.getValueAsBit("HideInTests"))
+      OS << ", true";
+    else
+      OS << ", false";
+
     // Category number.
     OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
     OS << ")\n";
   }
 }
 } // end namespace clang
 
 //===----------------------------------------------------------------------===//