Merge from 'master' to 'sycl-web' (#16)

Author: bader

clang-tools-extra/clang-tidy/bugprone/MacroRepeatedSideEffectsCheck.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "MacroRepeatedSideEffectsCheck.h"
+#include "clang/Basic/Builtins.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/PPCallbacks.h"

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.cpp

@@ -20,11 +20,13 @@ namespace modernize {
 UseOverrideCheck::UseOverrideCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoreDestructors(Options.get("IgnoreDestructors", false)),
+      AllowOverrideAndFinal(Options.get("AllowOverrideAndFinal", false)),
       OverrideSpelling(Options.get("OverrideSpelling", "override")),
       FinalSpelling(Options.get("FinalSpelling", "final")) {}
 
 void UseOverrideCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreDestructors", IgnoreDestructors);
+  Options.store(Opts, "AllowOverrideAndFinal", AllowOverrideAndFinal);
   Options.store(Opts, "OverrideSpelling", OverrideSpelling);
   Options.store(Opts, "FinalSpelling", FinalSpelling);
 }
@@ -103,7 +105,8 @@ void UseOverrideCheck::check(const MatchFinder::MatchResult &Result) {
   bool OnlyVirtualSpecified = HasVirtual && !HasOverride && !HasFinal;
   unsigned KeywordCount = HasVirtual + HasOverride + HasFinal;
 
-  if (!OnlyVirtualSpecified && KeywordCount == 1)
+  if ((!OnlyVirtualSpecified && KeywordCount == 1) ||
+      (!HasVirtual && HasOverride && HasFinal && AllowOverrideAndFinal))
     return; // Nothing to do.
 
   std::string Message;
@@ -113,8 +116,9 @@ void UseOverrideCheck::check(const MatchFinder::MatchResult &Result) {
     Message = "annotate this function with '%0' or (rarely) '%1'";
   } else {
     StringRef Redundant =
-        HasVirtual ? (HasOverride && HasFinal ? "'virtual' and '%0' are"
-                                              : "'virtual' is")
+        HasVirtual ? (HasOverride && HasFinal && !AllowOverrideAndFinal
+                          ? "'virtual' and '%0' are"
+                          : "'virtual' is")
                    : "'%0' is";
     StringRef Correct = HasFinal ? "'%1'" : "'%0'";
 
@@ -211,7 +215,7 @@ void UseOverrideCheck::check(const MatchFinder::MatchResult &Result) {
     Diag << FixItHint::CreateInsertion(InsertLoc, ReplacementText);
   }
 
-  if (HasFinal && HasOverride) {
+  if (HasFinal && HasOverride && !AllowOverrideAndFinal) {
     SourceLocation OverrideLoc = Method->getAttr<OverrideAttr>()->getLocation();
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getTokenRange(OverrideLoc, OverrideLoc));

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.h

@@ -26,6 +26,7 @@ class UseOverrideCheck : public ClangTidyCheck {
 
 private:
   const bool IgnoreDestructors;
+  const bool AllowOverrideAndFinal;
   const std::string OverrideSpelling;
   const std::string FinalSpelling;
 };

clang-tools-extra/clang-tidy/readability/RedundantStringInitCheck.cpp

@@ -8,6 +8,7 @@
 
 #include "RedundantStringInitCheck.h"
 #include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
@@ -17,19 +18,43 @@ namespace clang {
 namespace tidy {
 namespace readability {
 
+const char DefaultStringNames[] = "::std::basic_string";
+
+RedundantStringInitCheck::RedundantStringInitCheck(StringRef Name,
+                                                   ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      StringNames(utils::options::parseStringList(
+          Options.get("StringNames", DefaultStringNames))) {}
+
+void RedundantStringInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "StringNames", DefaultStringNames);
+}
+
 void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
+  const auto hasStringTypeName = hasAnyName(
+      SmallVector<StringRef, 3>(StringNames.begin(), StringNames.end()));
+
+  // Version of StringNames with namespaces removed
+  std::vector<std::string> stringNamesNoNamespace;
+  for (const std::string &name : StringNames) {
+    std::string::size_type colonPos = name.rfind(':');
+    stringNamesNoNamespace.push_back(
+        name.substr(colonPos == std::string::npos ? 0 : colonPos + 1));
+  }
+  const auto hasStringCtorName = hasAnyName(SmallVector<StringRef, 3>(
+      stringNamesNoNamespace.begin(), stringNamesNoNamespace.end()));
 
   // Match string constructor.
-  const auto StringConstructorExpr = expr(anyOf(
-      cxxConstructExpr(argumentCountIs(1),
-                       hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
-      // If present, the second argument is the alloc object which must not
-      // be present explicitly.
-      cxxConstructExpr(argumentCountIs(2),
-                       hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
-                       hasArgument(1, cxxDefaultArgExpr()))));
+  const auto StringConstructorExpr = expr(
+      anyOf(cxxConstructExpr(argumentCountIs(1),
+                             hasDeclaration(cxxMethodDecl(hasStringCtorName))),
+            // If present, the second argument is the alloc object which must
+            // not be present explicitly.
+            cxxConstructExpr(argumentCountIs(2),
+                             hasDeclaration(cxxMethodDecl(hasStringCtorName)),
+                             hasArgument(1, cxxDefaultArgExpr()))));
 
   // Match a string constructor expression with an empty string literal.
   const auto EmptyStringCtorExpr = cxxConstructExpr(
@@ -48,7 +73,7 @@ void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
       namedDecl(
           varDecl(
               hasType(hasUnqualifiedDesugaredType(recordType(
-                  hasDeclaration(cxxRecordDecl(hasName("basic_string")))))),
+                  hasDeclaration(cxxRecordDecl(hasStringTypeName))))),
               hasInitializer(expr(ignoringImplicit(anyOf(
                   EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries)))))
               .bind("vardecl"),

clang-tools-extra/clang-tidy/readability/RedundantStringInitCheck.h

@@ -10,6 +10,8 @@
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H
 
 #include "../ClangTidyCheck.h"
+#include <string>
+#include <vector>
 
 namespace clang {
 namespace tidy {
@@ -18,10 +20,13 @@ namespace readability {
 /// Finds unnecessary string initializations.
 class RedundantStringInitCheck : public ClangTidyCheck {
 public:
-  RedundantStringInitCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  RedundantStringInitCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  std::vector<std::string> StringNames;
 };
 
 } // namespace readability

clang-tools-extra/clangd/index/FileIndex.cpp

@@ -16,6 +16,7 @@
 #include "index/Merge.h"
 #include "index/SymbolOrigin.h"
 #include "index/dex/Dex.h"
+#include "clang/AST/ASTContext.h"
 #include "clang/Index/IndexingAction.h"
 #include "clang/Index/IndexingOptions.h"
 #include "clang/Lex/MacroInfo.h"

clang-tools-extra/clangd/index/FileIndex.h

@@ -25,6 +25,7 @@
 #include <memory>
 
 namespace clang {
+class ASTContext;
 namespace clangd {
 class ParsedAST;
 

clang-tools-extra/docs/ReleaseNotes.rst

@@ -164,6 +164,16 @@ Improvements to clang-tidy
   Finds non-static member functions that can be made ``const``
   because the functions don't use ``this`` in a non-const way.
 
+- Improved :doc:`modernize-use-override
+  <clang-tidy/checks/modernize-use-override>` check.
+
+  The check now supports the ``AllowOverrideAndFinal`` option to eliminate
+  conflicts with ``gcc -Wsuggest-override`` or ``gcc -Werror=suggest-override``.
+
+- The :doc:`readability-redundant-string-init
+  <clang-tidy/checks/readability-redundant-string-init>` check now supports a
+  `StringNames` option enabling its application to custom string classes.
+
 Improvements to include-fixer
 -----------------------------
 

clang-tools-extra/docs/clang-tidy/checks/modernize-use-override.rst

@@ -27,6 +27,14 @@ Options
 
    If set to non-zero, this check will not diagnose destructors. Default is `0`.
 
+.. option:: AllowOverrideAndFinal
+
+   If set to non-zero, this check will not diagnose ``override`` as redundant
+   with ``final``. This is useful when code will be compiled by a compiler with
+   warning/error checking flags requiring ``override`` explicitly on overriden
+   members, such as ``gcc -Wsuggest-override``/``gcc -Werror=suggest-override``.
+   Default is `0`.
+
 .. option:: OverrideSpelling
 
    Specifies a macro to use instead of ``override``. This is useful when

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-string-init.rst

@@ -5,7 +5,8 @@ readability-redundant-string-init
 
 Finds unnecessary string initializations.
 
-Examples:
+Examples
+--------
 
 .. code-block:: c++
 
@@ -17,3 +18,15 @@ Examples:
 
   std::string a;
   std::string b;
+
+Options
+-------
+
+.. option:: StringNames
+
+    Default is `::std::basic_string`.
+
+    Semicolon-delimited list of class names to apply this check to.
+    By default `::std::basic_string` applies to ``std::string`` and
+    ``std::wstring``. Set to e.g. `::std::basic_string;llvm::StringRef;QString`
+    to perform this check on custom classes.

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-string-init.cpp

@@ -1,4 +1,9 @@
-// RUN: %check_clang_tidy %s readability-redundant-string-init %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s readability-redundant-string-init %t \
+// RUN:   -config="{CheckOptions: \
+// RUN:             [{key: readability-redundant-string-init.StringNames, \
+// RUN:               value: '::std::basic_string;our::TestString'}] \
+// RUN:             }"
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace std {
 template <typename T>
@@ -143,3 +148,82 @@ extern void Param2(const std::string& param = "");
 void Param3(std::string param = "") {}
 void Param4(STRING param = "") {}
 
+namespace our {
+struct TestString {
+  TestString();
+  TestString(const TestString &);
+  TestString(const char *);
+  ~TestString();
+};
+}
+
+void ourTestStringTests() {
+  our::TestString a = "";
+  // CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
+  // CHECK-FIXES: our::TestString a;
+  our::TestString b("");
+  // CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
+  // CHECK-FIXES: our::TestString b;
+  our::TestString c = R"()";
+  // CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
+  // CHECK-FIXES: our::TestString c;
+  our::TestString d(R"()");
+  // CHECK-MESSAGES: [[@LINE-1]]:19: warning: redundant string initialization
+  // CHECK-FIXES: our::TestString d;
+
+  our::TestString u = "u";
+  our::TestString w("w");
+  our::TestString x = R"(x)";
+  our::TestString y(R"(y)");
+  our::TestString z;
+}
+
+namespace their {
+using TestString = our::TestString;
+}
+
+// their::TestString is the same type so should warn / fix
+void theirTestStringTests() {
+  their::TestString a = "";
+  // CHECK-MESSAGES: [[@LINE-1]]:21: warning: redundant string initialization
+  // CHECK-FIXES: their::TestString a;
+  their::TestString b("");
+  // CHECK-MESSAGES: [[@LINE-1]]:21: warning: redundant string initialization
+  // CHECK-FIXES: their::TestString b;
+}
+
+namespace other {
+// Identical declarations to above but different type
+struct TestString {
+  TestString();
+  TestString(const TestString &);
+  TestString(const char *);
+  ~TestString();
+};
+
+// Identical declarations to above but different type
+template <typename T>
+class allocator {};
+template <typename T>
+class char_traits {};
+template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
+struct basic_string {
+  basic_string();
+  basic_string(const basic_string &);
+  basic_string(const C *, const A &a = A());
+  ~basic_string();
+};
+typedef basic_string<char> string;
+typedef basic_string<wchar_t> wstring;
+}
+
+// other::TestString, other::string, other::wstring are unrelated to the types
+// being checked. No warnings / fixes should be produced for these types.
+void otherTestStringTests() {
+  other::TestString a = "";
+  other::TestString b("");
+  other::string c = "";
+  other::string d("");
+  other::wstring e = L"";
+  other::wstring f(L"");
+}

clang/include/clang/Basic/Builtins.h

@@ -25,8 +25,6 @@
 namespace clang {
 class TargetInfo;
 class IdentifierTable;
-class ASTContext;
-class QualType;
 class LangOptions;
 
 enum LanguageID {

clang/include/clang/Basic/DebugInfoOptions.h

@@ -18,24 +18,30 @@ enum DebugInfoFormat {
 };
 
 enum DebugInfoKind {
-  NoDebugInfo,         /// Don't generate debug info.
-  LocTrackingOnly,     /// Emit location information but do not generate
-                       /// debug info in the output. This is useful in
-                       /// cases where the backend wants to track source
-                       /// locations for instructions without actually
-                       /// emitting debug info for them (e.g., when -Rpass
-                       /// is used).
-  DebugDirectivesOnly, /// Emit only debug directives with the line numbers data
-  DebugLineTablesOnly, /// Emit only debug info necessary for generating
-                       /// line number tables (-gline-tables-only).
-  LimitedDebugInfo,    /// Limit generated debug info to reduce size
-                       /// (-fno-standalone-debug). This emits
-                       /// forward decls for types that could be
-                       /// replaced with forward decls in the source
-                       /// code. For dynamic C++ classes type info
-                       /// is only emitted into the module that
-                       /// contains the classe's vtable.
-  FullDebugInfo        /// Generate complete debug info.
+  /// Don't generate debug info.
+  NoDebugInfo,
+
+  /// Emit location information but do not generate debug info in the output.
+  /// This is useful in cases where the backend wants to track source
+  /// locations for instructions without actually emitting debug info for them
+  /// (e.g., when -Rpass is used).
+  LocTrackingOnly,
+
+  /// Emit only debug directives with the line numbers data
+  DebugDirectivesOnly,
+
+  /// Emit only debug info necessary for generating line number tables
+  /// (-gline-tables-only).
+  DebugLineTablesOnly,
+
+  /// Limit generated debug info to reduce size (-fno-standalone-debug). This
+  /// emits forward decls for types that could be replaced with forward decls in
+  /// the source code. For dynamic C++ classes type info is only emitted into
+  /// the module that contains the classe's vtable.
+  LimitedDebugInfo,
+
+  /// Generate complete debug info.
+  FullDebugInfo
 };
 
 } // end namespace codegenoptions