[clang][clang-tools-extra] LLVM_NODISCARD => [[nodiscard]]. NFC

Author: MaskRay

clang-tools-extra/clang-tidy/ClangTidyOptions.h

@@ -63,8 +63,8 @@ struct ClangTidyOptions {
   /// Creates a new \c ClangTidyOptions instance combined from all fields
   /// of this instance overridden by the fields of \p Other that have a value.
   /// \p Order specifies precedence of \p Other option.
-  LLVM_NODISCARD ClangTidyOptions merge(const ClangTidyOptions &Other,
-                                        unsigned Order) const;
+  [[nodiscard]] ClangTidyOptions merge(const ClangTidyOptions &Other,
+                                       unsigned Order) const;
 
   /// Checks filter.
   llvm::Optional<std::string> Checks;

clang-tools-extra/clangd/ClangdServer.cpp

@@ -1000,7 +1000,7 @@ llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats() const {
   return WorkScheduler->fileStats();
 }
 
-LLVM_NODISCARD bool
+[[nodiscard]] bool
 ClangdServer::blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds) {
   // Order is important here: we don't want to block on A and then B,
   // if B might schedule work on A.

clang-tools-extra/clangd/ClangdServer.h

@@ -390,7 +390,7 @@ class ClangdServer {
   // Returns false if the timeout expires.
   // FIXME: various subcomponents each get the full timeout, so it's more of
   // an order of magnitude than a hard deadline.
-  LLVM_NODISCARD bool
+  [[nodiscard]] bool
   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10);
 
   /// Builds a nested representation of memory used by components.

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

@@ -110,7 +110,7 @@ class BackgroundQueue {
   // Disables thread priority lowering to ensure progress on loaded systems.
   // Only affects tasks that run after the call.
   static void preventThreadStarvationInTests();
-  LLVM_NODISCARD bool
+  [[nodiscard]] bool
   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds);
 
 private:
@@ -172,7 +172,7 @@ class BackgroundIndex : public SwapIndex {
   }
 
   // Wait until the queue is empty, to allow deterministic testing.
-  LLVM_NODISCARD bool
+  [[nodiscard]] bool
   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10) {
     return Queue.blockUntilIdleForTest(TimeoutSeconds);
   }

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

@@ -116,7 +116,7 @@ class Reader {
   // Read a varint (as consumeVar) and resize the container accordingly.
   // If the size is invalid, return false and mark an error.
   // (The caller should abort in this case).
-  template <typename T> LLVM_NODISCARD bool consumeSize(T &Container) {
+  template <typename T> [[nodiscard]] bool consumeSize(T &Container) {
     auto Size = consumeVar();
     // Conservatively assume each element is at least one byte.
     if (Size > (size_t)(End - Begin)) {

clang-tools-extra/clangd/support/Context.h

@@ -184,7 +184,7 @@ class Context {
 /// WithContext replaces Context::current() with a provided scope.
 /// When the WithContext is destroyed, the original scope is restored.
 /// For extending the current context with new value, prefer WithContextValue.
-class LLVM_NODISCARD WithContext {
+class [[nodiscard]] WithContext {
 public:
   WithContext(Context C) : Restore(Context::swapCurrent(std::move(C))) {}
   ~WithContext() { Context::swapCurrent(std::move(Restore)); }
@@ -199,7 +199,7 @@ class LLVM_NODISCARD WithContext {
 
 /// WithContextValue extends Context::current() with a single value.
 /// When the WithContextValue is destroyed, the original scope is restored.
-class LLVM_NODISCARD WithContextValue {
+class [[nodiscard]] WithContextValue {
 public:
   template <typename T>
   WithContextValue(const Key<T> &K, typename std::decay<T>::type V)

clang-tools-extra/clangd/support/Function.h

@@ -35,7 +35,7 @@ template <typename T> class Event {
 
   // A subscription defines the scope of when a listener should receive events.
   // After destroying the subscription, no more events are received.
-  class LLVM_NODISCARD Subscription {
+  class [[nodiscard]] Subscription {
     Event *Parent;
     unsigned ListenerID;
 

clang-tools-extra/clangd/support/Threading.h

@@ -76,8 +76,8 @@ void wait(std::unique_lock<std::mutex> &Lock, std::condition_variable &CV,
           Deadline D);
 /// Waits on a condition variable until F() is true or D expires.
 template <typename Func>
-LLVM_NODISCARD bool wait(std::unique_lock<std::mutex> &Lock,
-                         std::condition_variable &CV, Deadline D, Func F) {
+[[nodiscard]] bool wait(std::unique_lock<std::mutex> &Lock,
+                        std::condition_variable &CV, Deadline D, Func F) {
   while (!F()) {
     if (D.expired())
       return false;
@@ -93,7 +93,7 @@ class Notification {
   void notify();
   // Blocks until flag is set.
   void wait() const { (void)wait(Deadline::infinity()); }
-  LLVM_NODISCARD bool wait(Deadline D) const;
+  [[nodiscard]] bool wait(Deadline D) const;
 
 private:
   bool Notified = false;
@@ -110,7 +110,7 @@ class AsyncTaskRunner {
   ~AsyncTaskRunner();
 
   void wait() const { (void)wait(Deadline::infinity()); }
-  LLVM_NODISCARD bool wait(Deadline D) const;
+  [[nodiscard]] bool wait(Deadline D) const;
   // The name is used for tracing and debugging (e.g. to name a spawned thread).
   void runAsync(const llvm::Twine &Name, llvm::unique_function<void()> Action);
 

clang/include/clang/AST/ASTContext.h

@@ -3202,11 +3202,11 @@ OPT_LIST(V)
 
 #undef OPT_LIST
 
-    LLVM_NODISCARD ObjCEncOptions keepingOnly(ObjCEncOptions Mask) const {
+    [[nodiscard]] ObjCEncOptions keepingOnly(ObjCEncOptions Mask) const {
       return Bits & Mask.Bits;
     }
 
-    LLVM_NODISCARD ObjCEncOptions forComponentType() const {
+    [[nodiscard]] ObjCEncOptions forComponentType() const {
       ObjCEncOptions Mask = ObjCEncOptions()
                                 .setIsOutermostType()
                                 .setIsStructField();

clang/include/clang/AST/ASTImporter.h

@@ -304,7 +304,7 @@ class TypeSourceInfo;
     /// \param From Object to import.
     /// \return Error information (success or error).
     template <typename ImportT>
-    LLVM_NODISCARD llvm::Error importInto(ImportT &To, const ImportT &From) {
+    [[nodiscard]] llvm::Error importInto(ImportT &To, const ImportT &From) {
       auto ToOrErr = Import(From);
       if (ToOrErr)
         To = *ToOrErr;
@@ -482,7 +482,7 @@ class TypeSourceInfo;
 
     /// Import the definition of the given declaration, including all of
     /// the declarations it contains.
-    LLVM_NODISCARD llvm::Error ImportDefinition(Decl *From);
+    [[nodiscard]] llvm::Error ImportDefinition(Decl *From);
 
     /// Cope with a name conflict when importing a declaration into the
     /// given context.

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

@@ -164,7 +164,7 @@ class SymbolGraphSerializer : public APISerializer {
   /// \param Component The component to push onto the path components stack.
   /// \return A PathComponentGuard responsible for removing the latest
   /// component from the stack on scope exit.
-  LLVM_NODISCARD PathComponentGuard makePathComponentGuard(StringRef Component);
+  [[nodiscard]] PathComponentGuard makePathComponentGuard(StringRef Component);
 
 public:
   SymbolGraphSerializer(const APISet &API, StringRef ProductName,

clang/include/clang/StaticAnalyzer/Checkers/Taint.h

@@ -27,39 +27,39 @@ using TaintTagType = unsigned;
 static constexpr TaintTagType TaintTagGeneric = 0;
 
 /// Create a new state in which the value of the statement is marked as tainted.
-LLVM_NODISCARD ProgramStateRef addTaint(ProgramStateRef State, const Stmt *S,
-                                        const LocationContext *LCtx,
-                                        TaintTagType Kind = TaintTagGeneric);
+[[nodiscard]] ProgramStateRef addTaint(ProgramStateRef State, const Stmt *S,
+                                       const LocationContext *LCtx,
+                                       TaintTagType Kind = TaintTagGeneric);
 
 /// Create a new state in which the value is marked as tainted.
-LLVM_NODISCARD ProgramStateRef addTaint(ProgramStateRef State, SVal V,
-                                        TaintTagType Kind = TaintTagGeneric);
+[[nodiscard]] ProgramStateRef addTaint(ProgramStateRef State, SVal V,
+                                       TaintTagType Kind = TaintTagGeneric);
 
 /// Create a new state in which the symbol is marked as tainted.
-LLVM_NODISCARD ProgramStateRef addTaint(ProgramStateRef State, SymbolRef Sym,
-                                        TaintTagType Kind = TaintTagGeneric);
+[[nodiscard]] ProgramStateRef addTaint(ProgramStateRef State, SymbolRef Sym,
+                                       TaintTagType Kind = TaintTagGeneric);
 
 /// Create a new state in which the pointer represented by the region
 /// is marked as tainted.
-LLVM_NODISCARD ProgramStateRef addTaint(ProgramStateRef State,
-                                        const MemRegion *R,
-                                        TaintTagType Kind = TaintTagGeneric);
+[[nodiscard]] ProgramStateRef addTaint(ProgramStateRef State,
+                                       const MemRegion *R,
+                                       TaintTagType Kind = TaintTagGeneric);
 
-LLVM_NODISCARD ProgramStateRef removeTaint(ProgramStateRef State, SVal V);
+[[nodiscard]] ProgramStateRef removeTaint(ProgramStateRef State, SVal V);
 
-LLVM_NODISCARD ProgramStateRef removeTaint(ProgramStateRef State,
-                                           const MemRegion *R);
+[[nodiscard]] ProgramStateRef removeTaint(ProgramStateRef State,
+                                          const MemRegion *R);
 
-LLVM_NODISCARD ProgramStateRef removeTaint(ProgramStateRef State,
-                                           SymbolRef Sym);
+[[nodiscard]] ProgramStateRef removeTaint(ProgramStateRef State, SymbolRef Sym);
 
 /// Create a new state in a which a sub-region of a given symbol is tainted.
 /// This might be necessary when referring to regions that can not have an
 /// individual symbol, e.g. if they are represented by the default binding of
 /// a LazyCompoundVal.
-LLVM_NODISCARD ProgramStateRef addPartialTaint(
-    ProgramStateRef State, SymbolRef ParentSym, const SubRegion *SubRegion,
-    TaintTagType Kind = TaintTagGeneric);
+[[nodiscard]] ProgramStateRef
+addPartialTaint(ProgramStateRef State, SymbolRef ParentSym,
+                const SubRegion *SubRegion,
+                TaintTagType Kind = TaintTagGeneric);
 
 /// Check if the statement has a tainted value in the given state.
 bool isTainted(ProgramStateRef State, const Stmt *S,

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h

@@ -190,7 +190,7 @@ template <typename T> class CallDescriptionMap {
   CallDescriptionMap(CallDescriptionMap &&) = default;
   CallDescriptionMap &operator=(CallDescriptionMap &&) = default;
 
-  LLVM_NODISCARD const T *lookup(const CallEvent &Call) const {
+  [[nodiscard]] const T *lookup(const CallEvent &Call) const {
     // Slow path: linear lookup.
     // TODO: Implement some sort of fast path.
     for (const std::pair<CallDescription, T> &I : LinearMap)
@@ -212,7 +212,7 @@ template <typename T> class CallDescriptionMap {
   /// information, such as the precise argument count (see comments for
   /// CallEvent::getNumArgs), the called function if it was called through a
   /// function pointer, and other information not available syntactically.
-  LLVM_NODISCARD const T *lookupAsWritten(const CallExpr &Call) const {
+  [[nodiscard]] const T *lookupAsWritten(const CallExpr &Call) const {
     // Slow path: linear lookup.
     // TODO: Implement some sort of fast path.
     for (const std::pair<CallDescription, T> &I : LinearMap)
@@ -235,7 +235,7 @@ class CallDescriptionSet {
   CallDescriptionSet(const CallDescriptionSet &) = delete;
   CallDescriptionSet &operator=(const CallDescription &) = delete;
 
-  LLVM_NODISCARD bool contains(const CallEvent &Call) const;
+  [[nodiscard]] bool contains(const CallEvent &Call) const;
 
   /// When available, always prefer lookup with a CallEvent! This function
   /// exists only when that is not available, for example, when _only_
@@ -249,7 +249,7 @@ class CallDescriptionSet {
   /// information, such as the precise argument count (see comments for
   /// CallEvent::getNumArgs), the called function if it was called through a
   /// function pointer, and other information not available syntactically.
-  LLVM_NODISCARD bool containsAsWritten(const CallExpr &CE) const;
+  [[nodiscard]] bool containsAsWritten(const CallExpr &CE) const;
 };
 
 } // namespace ento

clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h

@@ -899,18 +899,19 @@ class ExprEngine {
   /// Note whether this loop has any more iteratios to model. These methods are
   /// essentially an interface for a GDM trait. Further reading in
   /// ExprEngine::VisitObjCForCollectionStmt().
-  LLVM_NODISCARD static ProgramStateRef
+  [[nodiscard]] static ProgramStateRef
   setWhetherHasMoreIteration(ProgramStateRef State,
                              const ObjCForCollectionStmt *O,
                              const LocationContext *LC, bool HasMoreIteraton);
 
-  LLVM_NODISCARD static ProgramStateRef
+  [[nodiscard]] static ProgramStateRef
   removeIterationState(ProgramStateRef State, const ObjCForCollectionStmt *O,
                        const LocationContext *LC);
 
-  LLVM_NODISCARD static bool hasMoreIteration(ProgramStateRef State,
-                                              const ObjCForCollectionStmt *O,
-                                              const LocationContext *LC);
+  [[nodiscard]] static bool hasMoreIteration(ProgramStateRef State,
+                                             const ObjCForCollectionStmt *O,
+                                             const LocationContext *LC);
+
 private:
   /// Assuming we construct an array of non-POD types, this method allows us
   /// to store which element is to be constructed next.